diff --git a/src/main/java/com/culqi/apioperation/ResponseHelper.java b/src/main/java/com/culqi/apioperation/ResponseHelper.java index 2d4c8c4..4eb82ce 100644 --- a/src/main/java/com/culqi/apioperation/ResponseHelper.java +++ b/src/main/java/com/culqi/apioperation/ResponseHelper.java @@ -48,10 +48,19 @@ public ResponseCulqi list(String url, String params) { } } + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.secret_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } + HttpUrl urlquery = builder.build(); Request request = new Request.Builder() .url(urlquery) .header("Authorization","Bearer " + Culqi.secret_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION) .build(); Response response = client.newCall(request).execute(); @@ -67,11 +76,19 @@ public ResponseCulqi list(String url, String params) { String result = ""; try { String api_key = url.contains("tokens") || url.contains("confirm") ? Culqi.public_key : Culqi.secret_key; + String env = Config.X_CULQI_ENV_TEST; + if(api_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } String base_url = url.contains("tokens") ? config.API_SECURE : config.API_BASE; RequestBody body = RequestBody.create(JSON, jsonData); Request request = new Request.Builder() .url(base_url+url) .header("Authorization","Bearer " + api_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION) .post(body) .build(); Response response = client.newCall(request).execute(); @@ -86,12 +103,20 @@ public ResponseCulqi create(String url, String jsonData, String rsaId) { String result = ""; try { String api_key = url.contains("tokens") || url.contains("confirm") ? Culqi.public_key : Culqi.secret_key; + String env = Config.X_CULQI_ENV_TEST; + if(api_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } String base_url = url.contains("tokens") ? config.API_SECURE : config.API_BASE; RequestBody body = RequestBody.create(JSON, jsonData); Request request = new Request.Builder() .url(base_url+url) .header("Authorization","Bearer " + api_key) .header("x-culqi-rsa-id", rsaId) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION) .post(body) .build(); Response response = client.newCall(request).execute(); @@ -104,11 +129,20 @@ public ResponseCulqi create(String url, String jsonData, String rsaId) { public ResponseCulqi update(String url, String jsonData, String id) { String result = ""; - try {System.out.println(config.API_BASE+url+id); + try { + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.secret_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } + System.out.println(config.API_BASE+url+id); RequestBody body = RequestBody.create(JSON, jsonData); Request request = new Request.Builder() .url(config.API_BASE+url+id) .header("Authorization","Bearer " + Culqi.secret_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION) .patch(body) .build(); Response response = client.newCall(request).execute(); @@ -122,11 +156,19 @@ public ResponseCulqi update(String url, String jsonData, String id) { public ResponseCulqi update(String url, String jsonData, String id, String rsaId) { String result = ""; try { + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.secret_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } RequestBody body = RequestBody.create(JSON, jsonData); Request request = new Request.Builder() .url(config.API_BASE+url+id) .header("Authorization","Bearer " + Culqi.secret_key) .header("x-culqi-rsa-id", rsaId) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION) .patch(body) .build(); Response response = client.newCall(request).execute(); @@ -140,10 +182,18 @@ public ResponseCulqi update(String url, String jsonData, String id, String rsaI public ResponseCulqi get_or_delete(String url, String id, boolean delete) { String result = ""; try { + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.secret_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } Request.Builder builder = new Request.Builder(); builder.url(config.API_BASE + url + id); System.out.println(config.API_BASE + url + id); - builder.header("Authorization","Bearer " + Culqi.secret_key); + builder.header("Authorization","Bearer " + Culqi.secret_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION); if (delete) { builder.delete(); } @@ -159,10 +209,18 @@ public ResponseCulqi get_or_delete(String url, String id, boolean delete) { public ResponseCulqi capture(String url, String id) throws Exception { String result = ""; try { + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.secret_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } RequestBody body = RequestBody.create(JSON, ""); Request.Builder builder = new Request.Builder(); builder.url(config.API_BASE + url + id + "/capture/"); - builder.header("Authorization", "Bearer " + Culqi.secret_key); + builder.header("Authorization", "Bearer " + Culqi.secret_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION); builder.post(body); Request request = builder.build(); Response response = client.newCall(request).execute(); @@ -176,10 +234,18 @@ public ResponseCulqi capture(String url, String id) throws Exception { public ResponseCulqi confirm(String url, String id) throws Exception { String result = ""; try { + String env = Config.X_CULQI_ENV_TEST; + if(Culqi.public_key.contains("live")) { + env = Config.X_CULQI_ENV_LIVE; + } RequestBody body = RequestBody.create(JSON, ""); Request.Builder builder = new Request.Builder(); builder.url(config.API_BASE+url+id+"/confirm/"); - builder.header("Authorization","Bearer " + Culqi.public_key); + builder.header("Authorization","Bearer " + Culqi.public_key) + .header("x-culqi-env", env) + .header("x-culqi-client", Config.X_CULQI_CLIENT) + .header("x-culqi-client-version", Config.X_CULQI_CLIENT_VERSION) + .header("x-api-version", Config.X_API_VERSION); builder.post(body); Request request = builder.build(); Response response = client.newCall(request).execute(); diff --git a/src/main/java/com/culqi/apioperation/service/Generic.java b/src/main/java/com/culqi/apioperation/service/Generic.java index 0006aba..c0a1c03 100644 --- a/src/main/java/com/culqi/apioperation/service/Generic.java +++ b/src/main/java/com/culqi/apioperation/service/Generic.java @@ -1,5 +1,6 @@ package com.culqi.apioperation.service; +import java.io.IOException; import java.util.Map; import com.culqi.apioperation.All; @@ -7,6 +8,8 @@ import com.culqi.apioperation.Find; import com.culqi.apioperation.ObjectResult; import com.culqi.model.ResponseCulqi; +import com.culqi.util.validation.*; +import com.fasterxml.jackson.databind.ObjectMapper; public class Generic implements All, Create, Find { @@ -16,8 +19,17 @@ public Generic(String url) { this.URL = url; } + ObjectMapper mapper = new ObjectMapper(); + public ResponseCulqi list(Map params) throws Exception { params = (params == null || params.size() == 0) ? null : params; + Map validationResponse = verifyClassValidationList(params, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().list(this.URL.replace("/",""), params); } @@ -26,6 +38,13 @@ public ResponseCulqi list() throws Exception { } public ResponseCulqi create(Map body) throws Exception { + Map validationResponse = verifyClassValidationCreate(body, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().create(body, this.URL); } @@ -34,19 +53,143 @@ public ResponseCulqi create(Map body, String rsaPublicKey, Strin } public ResponseCulqi get(String id) throws Exception { + Map validationResponse = verifyClassValidationUpdate(id, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().get_or_delete(this.URL, id, false); } public ResponseCulqi update(Map body, String id) throws Exception { + Map validationResponse = verifyClassValidationUpdate(id, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().update(body, this.URL, id); } public ResponseCulqi update(Map body, String id, String rsaPublicKey, String rsaId) throws Exception { + Map validationResponse = verifyClassValidationUpdate(id, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().update(body, this.URL, id, rsaPublicKey, rsaId); } public ResponseCulqi delete(String id) throws Exception { + Map validationResponse = verifyClassValidationUpdate(id, this.URL); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().get_or_delete(this.URL, id, true); } + private static Map verifyClassValidationCreate(Map body, String url) throws Exception { + try { + if (url.contains("tokens")) { + TokenValidation.create(body); + } + if (url.contains("charges")) { + ChargeValidation.create(body); + } + if (url.contains("refunds")) { + RefundValidation.create(body); + } + if (url.contains("plans")) { + PlanValidation.create(body); + } + if (url.contains("customers")) { + CustomerValidation.create(body); + } + if (url.contains("cards")) { + CardValidation.create(body); + } + if (url.contains("subscriptions")) { + SubscriptionValidation.create(body); + } + if (url.contains("orders")) { + OrderValidation.create(body); + } + } catch (CustomException e) { + return e.getErrorData(); + } + return null; + } + + private static Map verifyClassValidationUpdate(String id, String url) throws Exception { + try { + if (url.contains("tokens")) { + Helper.validateStringStart(id, "tkn"); + } + if (url.contains("charges")) { + Helper.validateStringStart(id, "chr"); + } + if (url.contains("refunds")) { + Helper.validateStringStart(id, "ref"); + } + if (url.contains("plans")) { + Helper.validateStringStart(id, "pln"); + } + if (url.contains("customers")) { + Helper.validateStringStart(id, "cus"); + } + if (url.contains("cards")) { + Helper.validateStringStart(id, "crd"); + } + if (url.contains("subscriptions")) { + Helper.validateStringStart(id, "sxn"); + } + if (url.contains("orders")) { + Helper.validateStringStart(id, "ord"); + } + } catch (CustomException e) { + return e.getErrorData(); + } + return null; + } + + private static Map verifyClassValidationList(Map params, String url) throws Exception { + try { + if (url.contains("tokens")) { + TokenValidation.list(params); + } + if (url.contains("charges")) { + ChargeValidation.list(params); + } + if (url.contains("refunds")) { + RefundValidation.list(params); + } + if (url.contains("plans")) { + PlanValidation.list(params); + } + if (url.contains("customers")) { + CustomerValidation.list(params); + } + if (url.contains("cards")) { + CardValidation.list(params); + } + if (url.contains("subscriptions")) { + SubscriptionValidation.list(params); + } + if (url.contains("orders")) { + OrderValidation.list(params); + } + } catch (CustomException e) { + return e.getErrorData(); + } + return null; // No validation errors + } + } diff --git a/src/main/java/com/culqi/apioperation/service/Order.java b/src/main/java/com/culqi/apioperation/service/Order.java index 9326314..703812b 100644 --- a/src/main/java/com/culqi/apioperation/service/Order.java +++ b/src/main/java/com/culqi/apioperation/service/Order.java @@ -4,6 +4,9 @@ import com.culqi.apioperation.ObjectResult; import com.culqi.model.ResponseCulqi; +import com.culqi.util.validation.CustomException; +import com.culqi.util.validation.Helper; +import com.culqi.util.validation.TokenValidation; /** * Created by culqi on 12/22/16. @@ -18,11 +21,35 @@ public Order() { } public ResponseCulqi confirm(String id) throws Exception { + Map validationResponse = verifyClassValidationConfirm(id); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().confirm(this.URL, id); } public ResponseCulqi confirm_order_type(Map body) throws Exception { + String id = (String)body.get("order_id"); + Map validationResponse = verifyClassValidationConfirm(id); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().create(body, this.URL+"confirm"); } + + private static Map verifyClassValidationConfirm(String id) throws Exception { + try { + Helper.validateStringStart(id, "ord"); + } catch (CustomException e) { + return e.getErrorData(); + } + return null; + } } diff --git a/src/main/java/com/culqi/apioperation/service/Token.java b/src/main/java/com/culqi/apioperation/service/Token.java index fe06b15..16a0ad0 100644 --- a/src/main/java/com/culqi/apioperation/service/Token.java +++ b/src/main/java/com/culqi/apioperation/service/Token.java @@ -4,6 +4,7 @@ import com.culqi.apioperation.ObjectResult; import com.culqi.model.ResponseCulqi; +import com.culqi.util.validation.*; /** * Created by culqi on 12/21/16. @@ -19,7 +20,23 @@ public Token() { } public ResponseCulqi createYape(Map body) throws Exception { + Map validationResponse = verifyClassValidationYape(body); + if (validationResponse != null) { + ResponseCulqi response = new ResponseCulqi(); + response.setStatusCode(400); + response.setBody(mapper.writeValueAsString(validationResponse)); + return response; + } return new ObjectResult().create(body, this.URL_YAPE); } + private static Map verifyClassValidationYape(Map body) throws Exception { + try { + TokenValidation.createTokenYapeValidation(body); + } catch (CustomException e) { + return e.getErrorData(); + } + return null; + } + } diff --git a/src/main/java/com/culqi/model/Config.java b/src/main/java/com/culqi/model/Config.java index 59a2940..fba4362 100644 --- a/src/main/java/com/culqi/model/Config.java +++ b/src/main/java/com/culqi/model/Config.java @@ -11,5 +11,11 @@ public class Config { public static final String DOMAIN = "api.culqi.com"; public static final String PATH = "/v2"; + + public static final String X_CULQI_ENV_TEST = "test"; + public static final String X_CULQI_ENV_LIVE = "live"; + public static final String X_API_VERSION = "2"; + public static final String X_CULQI_CLIENT = "culqi-java"; + public static final String X_CULQI_CLIENT_VERSION = "2.0.3"; } diff --git a/src/main/java/com/culqi/util/CountryCodes.java b/src/main/java/com/culqi/util/CountryCodes.java new file mode 100644 index 0000000..427fbe3 --- /dev/null +++ b/src/main/java/com/culqi/util/CountryCodes.java @@ -0,0 +1,32 @@ +package com.culqi.util; + +import java.util.Arrays; +import java.util.List; + +public class CountryCodes { + /** + * Returns a list of country codes. + * + * @return a list of country codes + */ + public static List getCountryCodes() { + return Arrays.asList( + "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", + "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BL", "BM", "BN", "BO", "BQ", "BR", "BS", + "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", + "CO", "CR", "CU", "CV", "CW", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", + "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", + "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", + "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", + "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", + "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK", + "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", + "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", + "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", + "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "SS", + "ST", "SV", "SX", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", + "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", + "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW" + ); + } +} diff --git a/src/main/java/com/culqi/util/Util.java b/src/main/java/com/culqi/util/Util.java index d7e00e4..bee7212 100644 --- a/src/main/java/com/culqi/util/Util.java +++ b/src/main/java/com/culqi/util/Util.java @@ -18,4 +18,6 @@ public String ramdonString() { return UUID.randomUUID().toString(); } + + } diff --git a/src/main/java/com/culqi/util/validation/CardValidation.java b/src/main/java/com/culqi/util/validation/CardValidation.java new file mode 100644 index 0000000..4bbc145 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/CardValidation.java @@ -0,0 +1,34 @@ +package com.culqi.util.validation; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +import com.culqi.util.CountryCodes; + +public class CardValidation { + public static void create(Map data) throws Exception { + Helper.validateStringStart((String) data.get("customer_id"), "cus"); + Helper.validateStringStart((String) data.get("token_id"), "tkn"); + } + + public static void list(Map data) throws Exception { + if (data.containsKey("card_brand")) { + List allowedBrandValues = Arrays.asList("Visa", "Mastercard", "Amex", "Diners"); + Helper.validateValue((String) data.get("card_brand"), allowedBrandValues); + } + + if (data.containsKey("card_type")) { + List allowedCardTypeValues = Arrays.asList("credito", "debito", "internacional"); + Helper.validateValue((String) data.get("card_type"), allowedCardTypeValues); + } + + if (data.containsKey("country_code")) { + List countryCodes = CountryCodes.getCountryCodes(); + Helper.validateValue((String) data.get("country_code"), countryCodes); + } + + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/ChargeValidation.java b/src/main/java/com/culqi/util/validation/ChargeValidation.java new file mode 100644 index 0000000..f394ea3 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/ChargeValidation.java @@ -0,0 +1,85 @@ +package com.culqi.util.validation; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +import com.culqi.util.CountryCodes; + +public class ChargeValidation { + public static void create(Map data) throws Exception { + String email = (String) data.get("email"); + if (!Helper.isValidEmail(email)) { + throw new CustomException("Invalid email."); + } + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + + Helper.validateCurrencyCode((String) data.get("currency_code").toString()); + + String sourceId = (String) data.get("source_id"); + + if (sourceId.startsWith("tkn")) { + Helper.validateStringStart(sourceId, "tkn"); + } else if (sourceId.startsWith("ype")) { + Helper.validateStringStart(sourceId, "ype"); + } else if (sourceId.startsWith("crd")) { + Helper.validateStringStart(sourceId, "crd"); + } else { + throw new CustomException("Incorrect format. The format must start with tkn, ype, or crd."); + } + } + + public static void list(Map data) throws Exception { + if (data.containsKey("currency_code")) { + Helper.validateCurrencyCode((String) data.get("currency_code").toString()); + } + if (data.containsKey("amount")) { + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("min_amount")) { + Object amountObj = data.get("min_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("max_amount")) { + Object amountObj = data.get("max_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("installments")) { + Object amountObj = data.get("installments"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("min_installments")) { + Object amountObj = data.get("min_installments"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("max_installments")) { + Object amountObj = data.get("max_installments"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("email")) { + String email = (String) data.get("email"); + if (!Helper.isValidEmail(email)) { + throw new CustomException("Invalid email."); + } + } + if (data.containsKey("card_brand")) { + List allowedBrandValues = Arrays.asList("Visa", "Mastercard", "Amex", "Diners"); + Helper.validateValue((String) data.get("card_brand"), allowedBrandValues); + } + + if (data.containsKey("card_type")) { + List allowedCardTypeValues = Arrays.asList("credito", "debito", "internacional"); + Helper.validateValue((String) data.get("card_type"), allowedCardTypeValues); + } + + if (data.containsKey("country_code")) { + List countryCodes = CountryCodes.getCountryCodes(); + Helper.validateValue((String) data.get("country_code"), countryCodes); + } + + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/CustomException.java b/src/main/java/com/culqi/util/validation/CustomException.java new file mode 100644 index 0000000..b1fb16f --- /dev/null +++ b/src/main/java/com/culqi/util/validation/CustomException.java @@ -0,0 +1,22 @@ +package com.culqi.util.validation; + +import java.util.HashMap; +import java.util.Map; + +public class CustomException extends Exception { + private Map errorData; + + public CustomException(String merchantMessage) { + super(merchantMessage); + errorData = new HashMap<>(); + errorData.put("object", "error"); + errorData.put("type", "param_error"); + errorData.put("merchant_message", merchantMessage); + errorData.put("user_message", merchantMessage); + } + + public Map getErrorData() { + return errorData; + } +} + diff --git a/src/main/java/com/culqi/util/validation/CustomerValidation.java b/src/main/java/com/culqi/util/validation/CustomerValidation.java new file mode 100644 index 0000000..badbb0f --- /dev/null +++ b/src/main/java/com/culqi/util/validation/CustomerValidation.java @@ -0,0 +1,54 @@ +package com.culqi.util.validation; +import java.util.List; +import java.util.Map; + +import com.culqi.util.CountryCodes; + +public class CustomerValidation { + public static void create(Map data) throws Exception { + String first_name = (String) data.get("first_name"); + String last_name = (String) data.get("last_name"); + String address = (String) data.get("address"); + String address_city = (String) data.get("address_city"); + if (first_name == null || first_name.isEmpty()) { + throw new CustomException("first name is empty."); + } + + if (last_name == null || last_name.isEmpty()) { + throw new CustomException("last name is empty."); + } + + if (address == null || address.isEmpty()) { + throw new CustomException("address is empty."); + } + + if (address_city == null || address_city.isEmpty()) { + throw new CustomException("address_city is empty."); + } + + if (!(data.get("phone_number") instanceof String)) { + throw new CustomException("Invalid 'phone_number'. It should be a string."); + } + + List countryCodes = CountryCodes.getCountryCodes(); + Helper.validateValue((String) data.get("country_code"), countryCodes); + + String email = (String) data.get("email"); + if (!Helper.isValidEmail(email)) { + throw new CustomException("Invalid email."); + } + } + + public static void list(Map data) throws Exception { + if (data.containsKey("email")) { + String email = (String) data.get("email"); + if (!Helper.isValidEmail(email)) { + throw new CustomException("Invalid email."); + } + } + if (data.containsKey("country_code")) { + List countryCodes = CountryCodes.getCountryCodes(); + Helper.validateValue((String) data.get("country_code"), countryCodes); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/Helper.java b/src/main/java/com/culqi/util/validation/Helper.java new file mode 100644 index 0000000..4167093 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/Helper.java @@ -0,0 +1,86 @@ +package com.culqi.util.validation; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import java.time.LocalDateTime; +import java.time.Instant; +import java.util.Arrays; +import java.util.List; + +public class Helper { + public void validateAmount(Object amount) throws Exception { + if (!(amount instanceof Integer || amount instanceof Float) || + ((Number) amount).intValue() != ((Number) amount).doubleValue()) { + throw new CustomException("Invalid amount."); + } + } + + public static boolean isValidCardNumber(String number) { + Pattern pattern = Pattern.compile("^\\d{13,19}$"); + Matcher matcher = pattern.matcher(number); + return matcher.matches(); + } + + public static boolean isValidEmail(String email) { + Pattern pattern = Pattern.compile("^\\S+@\\S+\\.\\S+$"); + Matcher matcher = pattern.matcher(email); + return matcher.matches(); + } + + public static void validateCurrencyCode(String currencyCode) throws Exception { + if (currencyCode == null || currencyCode.isEmpty()) { + throw new CustomException("Currency code is empty."); + } + + List allowedValues = Arrays.asList("PEN", "USD"); + if (!allowedValues.contains(currencyCode)) { + throw new CustomException("Currency code must be either \"PEN\" or \"USD\"."); + } + } + + public static void validateStringStart(String string, String start) throws Exception { + if (!(string.startsWith(start + "_test_") || string.startsWith(start + "_live_"))) { + throw new CustomException("Incorrect format. The format must start with " + start + "_test_ or " + start + "_live_"); + } + } + + public static void validateValue(String value, List allowedValues) throws Exception { + if (!allowedValues.contains(value)) { + System.err.println(value); + throw new CustomException("Invalid value. It must be one of " + allowedValues); + } + } + + public static boolean isFutureDate(long expirationDate) { + LocalDateTime expDate = LocalDateTime.ofInstant(Instant.ofEpochSecond(expirationDate), java.time.ZoneId.systemDefault()); + return expDate.isAfter(LocalDateTime.now()); + } + + public static void validateDateFilter(String dateFrom, String dateTo) throws CustomException { + int parsedDateFrom; + int parsedDateTo; + + try { + parsedDateFrom = Integer.parseInt(dateFrom); + parsedDateTo = Integer.parseInt(dateTo); + } catch (NumberFormatException e) { + throw new CustomException("Invalid value. Date_from and Date_to must be integers."); + } + + if (parsedDateTo < parsedDateFrom) { + throw new CustomException("Invalid value. Date_from must be less than Date_to."); + } + } + public static void validateAmountValue(Object amountObj) throws CustomException { + if (amountObj instanceof Integer) { + // Amount is already an integer, no further validation needed. + } else if (amountObj instanceof String) { + try { + int amount = Integer.parseInt((String) amountObj); + } catch (NumberFormatException e) { + throw new CustomException("Invalid 'amount'. It should be an integer or a string representing an integer."); + } + } else { + throw new CustomException("Invalid 'amount'. It should be an integer or a string representing an integer."); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/OrderValidation.java b/src/main/java/com/culqi/util/validation/OrderValidation.java new file mode 100644 index 0000000..3401186 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/OrderValidation.java @@ -0,0 +1,57 @@ +package com.culqi.util.validation; +import java.util.List; +import java.util.Map; + +import com.culqi.util.CountryCodes; + +public class OrderValidation { + public static void create(Map data) throws Exception { + Map clientDetails = (Map) data.get("client_details"); + String first_name = (String) clientDetails.get("first_name"); + String last_name = (String) clientDetails.get("last_name"); + String phone_number = (String) clientDetails.get("phone_number"); + String email = (String) clientDetails.get("email"); + if (first_name == null || first_name.isEmpty()) { + throw new Exception("first name is empty."); + } + + if (last_name == null || last_name.isEmpty()) { + throw new Exception("last name is empty."); + } + + if (phone_number == null || phone_number.isEmpty()) { + throw new Exception("phone_number is empty."); + } + + if (!Helper.isValidEmail(email)) { + throw new CustomException("Invalid email."); + } + + Helper.validateCurrencyCode((String) data.get("currency_code").toString()); + + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + + if (!Helper.isFutureDate((long) data.get("expiration_date"))) { + throw new Exception("expiration_date must be a future date."); + } + } + + public static void list(Map data) throws Exception { + if (data.containsKey("amount")) { + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("min_amount")) { + Object amountObj = data.get("min_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("max_amount")) { + Object amountObj = data.get("max_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/PlanValidation.java b/src/main/java/com/culqi/util/validation/PlanValidation.java new file mode 100644 index 0000000..8c9e2e1 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/PlanValidation.java @@ -0,0 +1,32 @@ +package com.culqi.util.validation; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +public class PlanValidation { + public static void create(Map data) throws Exception { + List allowedValues = Arrays.asList("dias", "semanas", "meses", "años"); + Helper.validateValue((String) data.get("interval"), allowedValues); + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + Helper.validateCurrencyCode((String) data.get("currency_code").toString()); + } + + public static void list(Map data) throws Exception { + if (data.containsKey("amount")) { + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("min_amount")) { + Object amountObj = data.get("min_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("max_amount")) { + Object amountObj = data.get("max_amount"); + Helper.validateAmountValue(amountObj); + } + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/RefundValidation.java b/src/main/java/com/culqi/util/validation/RefundValidation.java new file mode 100644 index 0000000..4de0575 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/RefundValidation.java @@ -0,0 +1,25 @@ +package com.culqi.util.validation; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +public class RefundValidation { + public static void create(Map data) throws Exception { + Helper.validateStringStart((String) data.get("charge_id"), "chr"); + List allowedReasonValues = Arrays.asList("duplicado", "fraudulento", "solicitud_comprador"); + Helper.validateValue((String) data.get("reason").toString(), allowedReasonValues); + Object amountObj = data.get("amount"); + Helper.validateAmountValue(amountObj); + } + + public static void list(Map data) throws Exception { + if (data.containsKey("reason")) { + List allowedReasonValues = Arrays.asList("duplicado", "fraudulento", "solicitud_comprador"); + Helper.validateValue((String) data.get("reason").toString(), allowedReasonValues); + } + + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/SubscriptionValidation.java b/src/main/java/com/culqi/util/validation/SubscriptionValidation.java new file mode 100644 index 0000000..6986cf7 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/SubscriptionValidation.java @@ -0,0 +1,19 @@ +package com.culqi.util.validation; +import java.util.Map; + +public class SubscriptionValidation { + public static void create(Map data) throws Exception { + Helper.validateStringStart((String) data.get("card_id"), "crd"); + Helper.validateStringStart((String) data.get("plan_id"), "pln"); + } + + public static void list(Map data) throws Exception { + if (data.containsKey("plan_id")) { + Helper.validateStringStart((String) data.get("plan_id"), "pln"); + } + + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/main/java/com/culqi/util/validation/TokenValidation.java b/src/main/java/com/culqi/util/validation/TokenValidation.java new file mode 100644 index 0000000..4549922 --- /dev/null +++ b/src/main/java/com/culqi/util/validation/TokenValidation.java @@ -0,0 +1,88 @@ +package com.culqi.util.validation; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import java.time.YearMonth; +import java.time.format.DateTimeFormatter; +import java.time.LocalDate; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +import com.culqi.util.CountryCodes; + +public class TokenValidation { + public static void create(Map body) throws Exception { + if (!Helper.isValidCardNumber((String) body.get("card_number"))) { + throw new CustomException("Invalid card number."); + } + + Pattern cvvPattern = Pattern.compile("^\\d{3,4}$"); + Matcher cvvMatcher = cvvPattern.matcher((String) body.get("cvv")); + if (!cvvMatcher.matches()) { + throw new CustomException("Invalid CVV."); + } + + if (!Helper.isValidEmail((String) body.get("email"))) { + throw new CustomException("Invalid email."); + } + + Pattern monthPattern = Pattern.compile("^(0?[1-9]|1[012])$"); + Matcher monthMatcher = monthPattern.matcher((String) body.get("expiration_month")); + if (!monthMatcher.matches()) { + throw new CustomException("Invalid expiration month."); + } + + Pattern yearPattern = Pattern.compile("^\\d{4}$"); + Matcher yearMatcher = yearPattern.matcher((String) body.get("expiration_year")); + int currentYear = LocalDate.now().getYear(); + if (!yearMatcher.matches() || Integer.parseInt((String) body.get("expiration_year")) < currentYear) { + throw new CustomException("Invalid expiration year."); + } + + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM"); + YearMonth expDate = YearMonth.parse((String) body.get("expiration_year") + "-" + (String) body.get("expiration_month"), formatter); + if (expDate.isBefore(YearMonth.now())) { + throw new CustomException("Card has expired."); + } + } + + public static void createTokenYapeValidation(Map data) throws CustomException { + Object amountObj = data.get("amount"); + + if (amountObj instanceof String) { + try { + int amount = Integer.parseInt((String) amountObj); + } catch (NumberFormatException e) { + throw new CustomException("Invalid 'amount'. It should be an integer or a string representing an integer."); + } + } else if (!(amountObj instanceof Integer)) { + throw new CustomException("Invalid 'amount'. It should be an integer or a string representing an integer."); + } + } + + public static void list(Map data) throws Exception { + if (data.containsKey("device_type")) { + List allowedDeviceValues = Arrays.asList("desktop", "mobile", "tablet"); + Helper.validateValue((String) data.get("device_type"), allowedDeviceValues); + } + + if (data.containsKey("card_brand")) { + List allowedBrandValues = Arrays.asList("Visa", "Mastercard", "Amex", "Diners"); + Helper.validateValue((String) data.get("card_brand"), allowedBrandValues); + } + + if (data.containsKey("card_type")) { + List allowedCardTypeValues = Arrays.asList("credito", "debito", "internacional"); + Helper.validateValue((String) data.get("card_type"), allowedCardTypeValues); + } + + if (data.containsKey("country_code")) { + List countryCodes = CountryCodes.getCountryCodes(); + Helper.validateValue((String) data.get("country_code"), countryCodes); + } + + if (data.containsKey("creation_date_from") && data.containsKey("creation_date_to")) { + Helper.validateDateFilter((String) data.get("creation_date_from"), (String) data.get("creation_date_to")); + } + } +} diff --git a/src/test/java/CulqiAllTest.java b/src/test/java/CulqiAllTest.java index 2338810..887774f 100644 --- a/src/test/java/CulqiAllTest.java +++ b/src/test/java/CulqiAllTest.java @@ -22,6 +22,7 @@ public class CulqiAllTest extends TestCase { public void test01_allTokens() throws Exception { Map res = mapper.readValue(culqiCRUD.tokens().getBody(), new TypeReference>(){}); List> data = (List>) res.get("data"); + System.err.println(res); assert(data.size() >= 0); } diff --git a/src/test/java/CulqiCreateTest.java b/src/test/java/CulqiCreateTest.java index 7254d0c..d2c672e 100644 --- a/src/test/java/CulqiCreateTest.java +++ b/src/test/java/CulqiCreateTest.java @@ -22,6 +22,7 @@ public class CulqiCreateTest extends TestCase { @Test public void test01_createToken() throws Exception { Map res = mapper.readValue(culqiCRUD.createToken().getBody(), new TypeReference>(){}); + System.err.println(res); assertEquals("token", res.get("object").toString()); } @@ -34,6 +35,7 @@ public void test02_createTokenEncrypt() throws Exception { @Test public void test03_createTokenYape() throws Exception { Map res = mapper.readValue(culqiCRUD.createTokenYape().getBody(), new TypeReference>(){}); + System.err.println(res); assertEquals("token",res.get("object").toString()); } @@ -42,8 +44,10 @@ public void test04_createCharge() throws Exception { ResponseCulqi response = culqiCRUD.createCharge(); Map res = mapper.readValue(response.getBody(), new TypeReference>(){}); if (response.getStatusCode()==200) { + System.err.println(response); assertEquals("REVIEW",res.get("action_code").toString()); }else if (response.getStatusCode()==201) { + System.err.println(res); assertEquals("charge",res.get("object").toString()); } } @@ -69,6 +73,7 @@ public void test05_createPlan() throws Exception { @Test public void test06_createCustomer() throws Exception { Map res = mapper.readValue(culqiCRUD.createCustomer().getBody(), new TypeReference>(){}); + System.err.println(res); assertEquals("customer",res.get("object").toString()); } @@ -79,7 +84,7 @@ public void test07_createCard() throws Exception { if (response.getStatusCode()==200) { assertEquals("REVIEW",res.get("action_code").toString()); }else if (response.getStatusCode()==201) { - assertEquals("charge",res.get("object").toString()); + assertEquals("card",res.get("object").toString()); } } diff --git a/src/test/java/CulqiPatchTest.java b/src/test/java/CulqiPatchTest.java index abcf3be..831f504 100644 --- a/src/test/java/CulqiPatchTest.java +++ b/src/test/java/CulqiPatchTest.java @@ -21,6 +21,7 @@ public class CulqiPatchTest extends TestCase { @Test public void test01_updateToken() throws Exception { Map res = mapper.readValue(culqiCRUD.updateToken().getBody(), new TypeReference>(){}); + System.err.println(res); assertEquals("token", res.get("object").toString()); } diff --git a/src/test/java/JsonData.java b/src/test/java/JsonData.java index f5ceb6b..0c5d417 100644 --- a/src/test/java/JsonData.java +++ b/src/test/java/JsonData.java @@ -144,7 +144,7 @@ protected Map jsonCustomer() throws Exception { customer.put("email", "tst" + new Util().ramdonString() + "@culqi.com"); customer.put("first_name", "Test"); customer.put("last_name", "Cuqli"); - customer.put("phone_number", 99004356); + customer.put("phone_number", "99004356"); return customer; }