Splits the token into header, body, and signature.
+ *
Decodes the header to retrieve the Key ID (kid).
+ *
Verifies the RSA signature using the public key associated with the kid.
+ *
If the signature is valid, decodes the body.
+ *
Optionally checks if the token has expired.
+ *
+ *
+ * @param token The JWT token string.
+ * @param requestContext The request context (can be null).
+ * @param checkExpiry Whether to validate the 'exp' claim.
+ * @return The token body as a Map if valid; otherwise, an empty Map.
+ * @throws JsonProcessingException If the header or body cannot be parsed as JSON.
+ */
+ private static Map validateToken(String token, Map requestContext, boolean checkExpiry)
+ throws JsonProcessingException {
+ String[] tokenElements = token.split("\\.");
+ // Basic JWT format check
+ if (tokenElements.length != 3) {
+ logger.info("Invalid token format: " + token);
+ return Collections.emptyMap();
+ }
+
+ String header = tokenElements[0];
+ String body = tokenElements[1];
+ String signature = tokenElements[2];
+ String payLoad = header + JsonKey.DOT_SEPARATOR + body;
+
+ // Decode header to get Key ID
+ Map headerData =
+ mapper.readValue(new String(decodeFromBase64(header), StandardCharsets.UTF_8), Map.class);
+ String keyId = headerData.get("kid").toString();
+
+ // Verify Signature
+ boolean isValid = CryptoUtil.verifyRSASign(
+ payLoad,
+ decodeFromBase64(signature),
+ KeyManager.getPublicKey(keyId).getPublicKey(),
+ JsonKey.SHA_256_WITH_RSA);
+
+ if (isValid) {
+ Map tokenBody =
+ mapper.readValue(new String(decodeFromBase64(body), StandardCharsets.UTF_8), Map.class);
+
+ if (checkExpiry) {
+ boolean isExp = isExpired((Integer) tokenBody.get("exp"));
+ if (isExp) {
+ logger.info("AccessTokenValidator: Token expired. Context: " + requestContext);
+ return Collections.emptyMap();
+ }
+ }
+ return tokenBody;
+ }
+ return Collections.emptyMap();
+ }
+
+ /**
+ * Managed user token verification.
+ * Validates the token and ensures the requested user IDs match the token claims.
+ *
+ * @param managedEncToken The managed token string.
+ * @param requestedByUserId User ID of the requester (must match parent).
+ * @param requestedForUserId User ID of the target user (must match sub).
+ * @param loggingHeaders Headers for logging logic.
+ * @return The managed user ID if valid, unauthorized otherwise.
+ */
+ public static String verifyManagedUserToken(
+ String managedEncToken, String requestedByUserId, String requestedForUserId, String loggingHeaders) {
+ return verifyManagedUserToken(managedEncToken, requestedByUserId, requestedForUserId, null, loggingHeaders);
+ }
+
+ /**
+ * managedtoken is validated and requestedByUserID, requestedForUserID values are validated
+ * aganist the managedEncToken
+ *
+ * @param managedEncToken
+ * @param requestedByUserId
+ * @param requestedForUserId
+ * @param requestContext
+ * @return
+ */
+ public static String verifyManagedUserToken(
+ String managedEncToken,
+ String requestedByUserId,
+ String requestedForUserId,
+ Map requestContext) {
+ return verifyManagedUserToken(managedEncToken, requestedByUserId, requestedForUserId, requestContext, null);
+ }
+
+ public static String verifyManagedUserToken(String managedEncToken, String requestedByUserId) {
+ return verifyManagedUserToken(managedEncToken, requestedByUserId, null, null, null);
+ }
+
+ private static String verifyManagedUserToken(
+ String managedEncToken,
+ String requestedByUserId,
+ String requestedForUserId,
+ Map requestContext,
+ String loggingHeaders) {
+ String managedFor = JsonKey.UNAUTHORIZED;
+ try {
+ Map payload;
+ if (requestContext != null) {
+ payload = validateToken(managedEncToken, requestContext);
+ } else {
+ payload = validateToken(managedEncToken, true);
+ }
+
+ if (MapUtils.isNotEmpty(payload)) {
+ String parentId = (String) payload.get(JsonKey.PARENT_ID);
+ String muaId = (String) payload.get(JsonKey.SUB);
+
+ String logMsg = String.format(
+ "AccessTokenValidator:verifyManagedUserToken: Parent: %s, ManagedBy: %s, RequestedBy: %s",
+ parentId, muaId, requestedByUserId);
+
+ if (StringUtils.isNotEmpty(requestedForUserId)) {
+ logMsg += ", RequestedFor: " + requestedForUserId;
+ }
+ if (requestContext != null) {
+ logMsg += ", Context: " + requestContext;
+ }
+
+ logger.info(logMsg);
+
+ boolean isValid = parentId.equalsIgnoreCase(requestedByUserId);
+ if (StringUtils.isNotEmpty(requestedForUserId) && !muaId.equalsIgnoreCase(requestedForUserId)) {
+ logger.info(String.format(
+ "AccessTokenValidator:verifyManagedUserToken: Mismatch! RequestedFor: %s, ManagedBy: %s, Headers: %s",
+ requestedForUserId, muaId, loggingHeaders));
+ // If requestedForUserId is present, it MUST match muaId for the token to be valid for that target
+ if (isValid) {
+ isValid = muaId.equalsIgnoreCase(requestedForUserId);
+ }
+ }
+
+ if (isValid) {
+ managedFor = muaId;
+ }
+ }
+ } catch (Exception ex) {
+ String errorMsg = "Exception in verifyManagedUserToken: Token : " + managedEncToken;
+ if (requestContext != null) {
+ errorMsg += ", request context data :" + requestContext;
+ }
+ logger.error(errorMsg, ex);
+ }
+ return managedFor;
+ }
+
+ /**
+ * Verifies the user access token.
+ *
+ * @param token The JWT access token.
+ * @param checkActive Whether to check for token expiration.
+ * @return The user ID from the token if valid, unauthorized otherwise.
+ */
+ public static String verifyUserToken(String token, boolean checkActive) {
+ return verifyUserToken(token, null, checkActive);
+ }
+
+ /**
+ * Verifies the user access token.
+ *
+ * @param token The JWT access token.
+ * @param requestContext Context for logging/tracing.
+ * @return The user ID from the token if valid, unauthorized otherwise.
+ */
+ public static String verifyUserToken(String token, Map requestContext) {
+ return verifyUserToken(token, requestContext, true);
+ }
+
+ /**
+ * Verifies the user access token with default expiration check.
+ *
+ * @param token The JWT access token.
+ * @return The user ID from the token if valid, unauthorized otherwise.
+ */
+ public static String verifyUserToken(String token) {
+ return verifyUserToken(token, null, true);
+ }
+
+ private static String verifyUserToken(String token, Map requestContext, boolean checkActive) {
+ String userId = JsonKey.UNAUTHORIZED;
+ try {
+ Map payload;
+ if (requestContext != null) {
+ payload = validateToken(token, requestContext);
+ logger.debug(
+ String.format("AccessTokenValidator:verifyUserToken: Payload: %s, Context: %s",
+ payload, requestContext));
+ } else {
+ payload = validateToken(token, checkActive);
+ }
+
+ if (MapUtils.isNotEmpty(payload) && checkIss((String) payload.get("iss"))) {
+ userId = (String) payload.get(JsonKey.SUB);
+ if (StringUtils.isNotBlank(userId)) {
+ int pos = userId.lastIndexOf(":");
+ userId = userId.substring(pos + 1);
+ }
+ }
+ } catch (Exception ex) {
+ String errorMsg = "Exception in verifyUserAccessToken: Token : " + token;
+ if (requestContext != null) {
+ errorMsg += ", request context data :" + requestContext;
+ }
+ logger.error(errorMsg, ex);
+ }
+
+ if (JsonKey.UNAUTHORIZED.equalsIgnoreCase(userId) && requestContext != null) {
+ logger.info(
+ String.format("AccessTokenValidator:verifyUserToken: Invalid Token. Context: %s", requestContext));
+ }
+
+ return userId;
+ }
+
+ /**
+ * Verifies the user token against a specific source URL.
+ *
+ * @param token The JWT access token string.
+ * @param url The source URL (SSO URL). If null, defaults to environment SUNBIRD_SSO_URL.
+ * @param requestContext Context for logging/tracing.
+ * @return The userId from the token if valid, otherwise JsonKey.UNAUTHORIZED.
+ */
+ public static String verifySourceUserToken(String token, String url, Map requestContext) {
+ String userId = JsonKey.UNAUTHORIZED;
+ try {
+ Map payload = validateToken(token, requestContext);
+ if (requestContext != null) {
+ logger.debug(
+ String.format("AccessTokenValidator:verifySourceUserToken: Payload: %s, Context: %s",
+ payload, requestContext));
+ }
+
+ if (MapUtils.isNotEmpty(payload) && checkSourceIss((String) payload.get("iss"), url)) {
+ userId = (String) payload.get(JsonKey.SUB);
+ if (StringUtils.isNotBlank(userId)) {
+ int pos = userId.lastIndexOf(":");
+ userId = userId.substring(pos + 1);
+ }
+ }
+ } catch (Exception ex) {
+ String errorMsg = "Exception in verifySourceUserToken: Token : " + token;
+ if (requestContext != null) {
+ errorMsg += ", request context data :" + requestContext;
+ }
+ logger.error(errorMsg, ex);
+ }
+
+ if (JsonKey.UNAUTHORIZED.equalsIgnoreCase(userId) && requestContext != null) {
+ logger.info(
+ String.format("AccessTokenValidator:verifySourceUserToken: Invalid Source Token. Context: %s", requestContext));
+ }
+ return userId;
+ }
+
+ private static boolean checkSourceIss(String iss, String url) {
+ String ssoUrl = (url != null ? url : sso_url);
+ String realmUrl = ssoUrl + "realms/" + realm;
+ return (realmUrl.equalsIgnoreCase(iss));
+ }
+
+ private static boolean checkIss(String iss) {
+ String realmUrl = sso_url + "realms/" + realm;
+ return (realmUrl.equalsIgnoreCase(iss));
+ }
+
+ private static boolean isExpired(Integer expiration) {
+ return (Time.currentTime() > expiration);
+ }
+
+ private static byte[] decodeFromBase64(String data) {
+ return Base64Util.decode(data, 11);
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/Base64Util.java b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/Base64Util.java
new file mode 100644
index 000000000..cfe4bba79
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/Base64Util.java
@@ -0,0 +1,692 @@
+package org.sunbird.auth.verifier;
+
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Utilities for encoding and decoding the Base64 representation of binary data. See RFCs 2045 and 3548.
+ */
+public class Base64Util {
+ /** Default values for encoder/decoder flags. */
+ public static final int DEFAULT = 0;
+
+ /** Encoder flag bit to omit the padding '=' characters at the end of the output (if any). */
+ public static final int NO_PADDING = 1;
+
+ /** Encoder flag bit to omit all line terminators (i.e., the output will be on one long line). */
+ public static final int NO_WRAP = 2;
+
+ /**
+ * Encoder flag bit to indicate lines should be terminated with a CRLF pair instead of just an LF.
+ * Has no effect if {@code NO_WRAP} is specified as well.
+ */
+ public static final int CRLF = 4;
+
+ /**
+ * Encoder/decoder flag bit to indicate using the "URL and filename safe" variant of Base64 (see
+ * RFC 3548 section 4) where {@code -} and {@code _} are used in place of {@code +} and {@code /}.
+ */
+ public static final int URL_SAFE = 8;
+
+ /**
+ * Flag to pass to {Base64OutputStream} to indicate that it should not close the output stream it
+ * is wrapping when it itself is closed.
+ */
+ public static final int NO_CLOSE = 16;
+
+ // --------------------------------------------------------
+ // shared code
+ // --------------------------------------------------------
+
+ private Base64Util() {} // don't instantiate
+
+ // --------------------------------------------------------
+ // decoding
+ // --------------------------------------------------------
+
+ /**
+ * Decode the Base64-encoded data in input and return the data in a new byte array.
+ *
+ *
+ *
+ *
The padding '=' characters at the end are considered optional, but if any are present, there
+ * must be the correct number of them.
+ *
+ * @param str the input String to decode, which is converted to bytes using the default charset
+ * @param flags controls certain features of the decoded output. Pass {@code DEFAULT} to decode
+ * standard Base64.
+ * @throws IllegalArgumentException if the input contains incorrect padding
+ */
+ public static byte[] decode(String str, int flags) {
+ return decode(str.getBytes(), flags);
+ }
+
+ /**
+ * Decode the Base64-encoded data in input and return the data in a new byte array.
+ *
+ *
+ *
+ *
The padding '=' characters at the end are considered optional, but if any are present, there
+ * must be the correct number of them.
+ *
+ * @param input the input array to decode
+ * @param flags controls certain features of the decoded output. Pass {@code DEFAULT} to decode
+ * standard Base64.
+ * @throws IllegalArgumentException if the input contains incorrect padding
+ */
+ public static byte[] decode(byte[] input, int flags) {
+ return decode(input, 0, input.length, flags);
+ }
+
+ /**
+ * Decode the Base64-encoded data in input and return the data in a new byte array.
+ *
+ *
+ *
+ *
The padding '=' characters at the end are considered optional, but if any are present, there
+ * must be the correct number of them.
+ *
+ * @param input the data to decode
+ * @param offset the position within the input array at which to start
+ * @param len the number of bytes of input to decode
+ * @param flags controls certain features of the decoded output. Pass {@code DEFAULT} to decode
+ * standard Base64.
+ * @throws IllegalArgumentException if the input contains incorrect padding
+ */
+ public static byte[] decode(byte[] input, int offset, int len, int flags) {
+ // Allocate space for the most data the input could represent.
+ // (It could contain less if it contains whitespace, etc.)
+ Decoder decoder = new Decoder(flags, new byte[len * 3 / 4]);
+
+ if (!decoder.process(input, offset, len, true)) {
+ throw new IllegalArgumentException("bad base-64");
+ }
+
+ // Maybe we got lucky and allocated exactly enough output space.
+ if (decoder.op == decoder.output.length) {
+ return decoder.output;
+ }
+
+ // Need to shorten the array, so allocate a new one of the
+ // right size and copy.
+ byte[] temp = new byte[decoder.op];
+ System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
+ return temp;
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated String with the result.
+ *
+ * @param input the data to encode
+ * @param flags controls certain features of the encoded output. Passing {@code DEFAULT} results
+ * in output that adheres to RFC 2045.
+ */
+ public static String encodeToString(byte[] input, int flags) {
+ try {
+ return new String(encode(input, flags), "US-ASCII");
+ } catch (UnsupportedEncodingException e) {
+ // US-ASCII is guaranteed to be available.
+ throw new AssertionError(e);
+ }
+ }
+
+ // --------------------------------------------------------
+ // encoding
+ // --------------------------------------------------------
+
+ /**
+ * Base64-encode the given data and return a newly allocated String with the result.
+ *
+ * @param input the data to encode
+ * @param offset the position within the input array at which to start
+ * @param len the number of bytes of input to encode
+ * @param flags controls certain features of the encoded output. Passing {@code DEFAULT} results
+ * in output that adheres to RFC 2045.
+ */
+ public static String encodeToString(byte[] input, int offset, int len, int flags) {
+ try {
+ return new String(encode(input, offset, len, flags), "US-ASCII");
+ } catch (UnsupportedEncodingException e) {
+ // US-ASCII is guaranteed to be available.
+ throw new AssertionError(e);
+ }
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated byte[] with the result.
+ *
+ * @param input the data to encode
+ * @param flags controls certain features of the encoded output. Passing {@code DEFAULT} results
+ * in output that adheres to RFC 2045.
+ */
+ public static byte[] encode(byte[] input, int flags) {
+ return encode(input, 0, input.length, flags);
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated byte[] with the result.
+ *
+ * @param input the data to encode
+ * @param offset the position within the input array at which to start
+ * @param len the number of bytes of input to encode
+ * @param flags controls certain features of the encoded output. Passing {@code DEFAULT} results
+ * in output that adheres to RFC 2045.
+ */
+ public static byte[] encode(byte[] input, int offset, int len, int flags) {
+ Encoder encoder = new Encoder(flags, null);
+
+ // Compute the exact length of the array we will produce.
+ int output_len = len / 3 * 4;
+
+ // Account for the tail of the data and the padding bytes, if any.
+ if (encoder.do_padding) {
+ if (len % 3 > 0) {
+ output_len += 4;
+ }
+ } else {
+ switch (len % 3) {
+ case 0:
+ break;
+ case 1:
+ output_len += 2;
+ break;
+ case 2:
+ output_len += 3;
+ break;
+ }
+ }
+
+ // Account for the newlines, if any.
+ if (encoder.do_newline && len > 0) {
+ output_len += (((len - 1) / (3 * Encoder.LINE_GROUPS)) + 1) * (encoder.do_cr ? 2 : 1);
+ }
+
+ encoder.output = new byte[output_len];
+ encoder.process(input, offset, len, true);
+
+ assert encoder.op == output_len;
+
+ return encoder.output;
+ }
+
+ /* package */ abstract static class Coder {
+ public byte[] output;
+ public int op;
+
+ /**
+ * Encode/decode another block of input data. this.output is provided by the caller, and must be
+ * big enough to hold all the coded data. On exit, this.opwill be set to the length of the coded
+ * data.
+ *
+ * @param finish true if this is the final call to process for this object. Will finalize the
+ * coder state and include any final bytes in the output.
+ * @return true if the input so far is good; false if some error has been detected in the input
+ * stream..
+ */
+ public abstract boolean process(byte[] input, int offset, int len, boolean finish);
+
+ /**
+ * @return the maximum number of bytes a call to process() could produce for the given number of
+ * input bytes. This may be an overestimate.
+ */
+ public abstract int maxOutputSize(int len);
+ }
+
+ /* package */ static class Decoder extends Coder {
+ /** Lookup table for turning bytes into their position in the Base64 alphabet. */
+ private static final int DECODE[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ };
+
+ /**
+ * Decode lookup table for the "web safe" variant (RFC 3548 sec. 4) where - and _ replace + and
+ * /.
+ */
+ private static final int DECODE_WEBSAFE[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ };
+
+ /** Non-data values in the DECODE arrays. */
+ private static final int SKIP = -1;
+
+ private static final int EQUALS = -2;
+ private final int[] alphabet;
+ /**
+ * States 0-3 are reading through the next input tuple. State 4 is having read one '=' and
+ * expecting exactly one more. State 5 is expecting no more data or padding characters in the
+ * input. State 6 is the error state; an error has been detected in the input and no future
+ * input can "fix" it.
+ */
+ private int state; // state number (0 to 6)
+
+ private int value;
+
+ public Decoder(int flags, byte[] output) {
+ this.output = output;
+
+ alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
+ state = 0;
+ value = 0;
+ }
+
+ /** @return an overestimate for the number of bytes {@code len} bytes could decode to. */
+ public int maxOutputSize(int len) {
+ return len * 3 / 4 + 10;
+ }
+
+ /**
+ * Decode another block of input data.
+ *
+ * @return true if the state machine is still healthy. false if bad base-64 data has been
+ * detected in the input stream.
+ */
+ public boolean process(byte[] input, int offset, int len, boolean finish) {
+ if (this.state == 6) return false;
+
+ int p = offset;
+ len += offset;
+
+ // Using local variables makes the decoder about 12%
+ // faster than if we manipulate the member variables in
+ // the loop. (Even alphabet makes a measurable
+ // difference, which is somewhat surprising to me since
+ // the member variable is final.)
+ int state = this.state;
+ int value = this.value;
+ int op = 0;
+ final byte[] output = this.output;
+ final int[] alphabet = this.alphabet;
+
+ while (p < len) {
+ // Try the fast path: we're starting a new tuple and the
+ // next four bytes of the input stream are all data
+ // bytes. This corresponds to going through states
+ // 0-1-2-3-0. We expect to use this method for most of
+ // the data.
+ //
+ // If any of the next four bytes of input are non-data
+ // (whitespace, etc.), value will end up negative. (All
+ // the non-data values in decode are small negative
+ // numbers, so shifting any of them up and or'ing them
+ // together will result in a value with its top bit set.)
+ //
+ // You can remove this whole block and the output should
+ // be the same, just slower.
+ if (state == 0) {
+ while (p + 4 <= len
+ && (value =
+ ((alphabet[input[p] & 0xff] << 18)
+ | (alphabet[input[p + 1] & 0xff] << 12)
+ | (alphabet[input[p + 2] & 0xff] << 6)
+ | (alphabet[input[p + 3] & 0xff])))
+ >= 0) {
+ output[op + 2] = (byte) value;
+ output[op + 1] = (byte) (value >> 8);
+ output[op] = (byte) (value >> 16);
+ op += 3;
+ p += 4;
+ }
+ if (p >= len) break;
+ }
+
+ // The fast path isn't available -- either we've read a
+ // partial tuple, or the next four input bytes aren't all
+ // data, or whatever. Fall back to the slower state
+ // machine implementation.
+
+ int d = alphabet[input[p++] & 0xff];
+
+ switch (state) {
+ case 0:
+ if (d >= 0) {
+ value = d;
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 1:
+ if (d >= 0) {
+ value = (value << 6) | d;
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 2:
+ if (d >= 0) {
+ value = (value << 6) | d;
+ ++state;
+ } else if (d == EQUALS) {
+ // Emit the last (partial) output tuple;
+ // expect exactly one more padding character.
+ output[op++] = (byte) (value >> 4);
+ state = 4;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 3:
+ if (d >= 0) {
+ // Emit the output triple and return to state 0.
+ value = (value << 6) | d;
+ output[op + 2] = (byte) value;
+ output[op + 1] = (byte) (value >> 8);
+ output[op] = (byte) (value >> 16);
+ op += 3;
+ state = 0;
+ } else if (d == EQUALS) {
+ // Emit the last (partial) output tuple;
+ // expect no further data or padding characters.
+ output[op + 1] = (byte) (value >> 2);
+ output[op] = (byte) (value >> 10);
+ op += 2;
+ state = 5;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 4:
+ if (d == EQUALS) {
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 5:
+ if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+ }
+ }
+
+ if (!finish) {
+ // We're out of input, but a future call could provide
+ // more.
+ this.state = state;
+ this.value = value;
+ this.op = op;
+ return true;
+ }
+
+ // Done reading input. Now figure out where we are left in
+ // the state machine and finish up.
+
+ switch (state) {
+ case 0:
+ // Output length is a multiple of three. Fine.
+ break;
+ case 1:
+ // Read one extra input byte, which isn't enough to
+ // make another output byte. Illegal.
+ this.state = 6;
+ return false;
+ case 2:
+ // Read two extra input bytes, enough to emit 1 more
+ // output byte. Fine.
+ output[op++] = (byte) (value >> 4);
+ break;
+ case 3:
+ // Read three extra input bytes, enough to emit 2 more
+ // output bytes. Fine.
+ output[op++] = (byte) (value >> 10);
+ output[op++] = (byte) (value >> 2);
+ break;
+ case 4:
+ // Read one padding '=' when we expected 2. Illegal.
+ this.state = 6;
+ return false;
+ case 5:
+ // Read all the padding '='s we expected and no more.
+ // Fine.
+ break;
+ }
+
+ this.state = state;
+ this.op = op;
+ return true;
+ }
+ }
+
+ /* package */ static class Encoder extends Coder {
+ /**
+ * Emit a new line every this many output tuples. Corresponds to a 76-character line length (the
+ * maximum allowable according to RFC 2045).
+ */
+ public static final int LINE_GROUPS = 19;
+
+ /** Lookup table for turning Base64 alphabet positions (6 bits) into output bytes. */
+ private static final byte ENCODE[] = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
+ };
+
+ /** Lookup table for turning Base64 alphabet positions (6 bits) into output bytes. */
+ private static final byte ENCODE_WEBSAFE[] = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
+ };
+
+ public final boolean do_padding;
+ public final boolean do_newline;
+ public final boolean do_cr;
+ private final byte[] tail;
+ private final byte[] alphabet;
+ /* package */ int tailLen;
+ private int count;
+
+ public Encoder(int flags, byte[] output) {
+ this.output = output;
+
+ do_padding = (flags & NO_PADDING) == 0;
+ do_newline = (flags & NO_WRAP) == 0;
+ do_cr = (flags & CRLF) != 0;
+ alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
+
+ tail = new byte[2];
+ tailLen = 0;
+
+ count = do_newline ? LINE_GROUPS : -1;
+ }
+
+ /** @return an overestimate for the number of bytes {@code len} bytes could encode to. */
+ public int maxOutputSize(int len) {
+ return len * 8 / 5 + 10;
+ }
+
+ public boolean process(byte[] input, int offset, int len, boolean finish) {
+ // Using local variables makes the encoder about 9% faster.
+ final byte[] alphabet = this.alphabet;
+ final byte[] output = this.output;
+ int op = 0;
+ int count = this.count;
+
+ int p = offset;
+ len += offset;
+ int v = -1;
+
+ // First we need to concatenate the tail of the previous call
+ // with any input bytes available now and see if we can empty
+ // the tail.
+
+ switch (tailLen) {
+ case 0:
+ // There was no tail.
+ break;
+
+ case 1:
+ if (p + 2 <= len) {
+ // A 1-byte tail with at least 2 bytes of
+ // input available now.
+ v = ((tail[0] & 0xff) << 16) | ((input[p++] & 0xff) << 8) | (input[p++] & 0xff);
+ tailLen = 0;
+ }
+ ;
+ break;
+
+ case 2:
+ if (p + 1 <= len) {
+ // A 2-byte tail with at least 1 byte of input.
+ v = ((tail[0] & 0xff) << 16) | ((tail[1] & 0xff) << 8) | (input[p++] & 0xff);
+ tailLen = 0;
+ }
+ break;
+ }
+
+ if (v != -1) {
+ output[op++] = alphabet[(v >> 18) & 0x3f];
+ output[op++] = alphabet[(v >> 12) & 0x3f];
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (--count == 0) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ count = LINE_GROUPS;
+ }
+ }
+
+ // At this point either there is no tail, or there are fewer
+ // than 3 bytes of input available.
+
+ // The main loop, turning 3 input bytes into 4 output bytes on
+ // each iteration.
+ while (p + 3 <= len) {
+ v = ((input[p] & 0xff) << 16) | ((input[p + 1] & 0xff) << 8) | (input[p + 2] & 0xff);
+ output[op] = alphabet[(v >> 18) & 0x3f];
+ output[op + 1] = alphabet[(v >> 12) & 0x3f];
+ output[op + 2] = alphabet[(v >> 6) & 0x3f];
+ output[op + 3] = alphabet[v & 0x3f];
+ p += 3;
+ op += 4;
+ if (--count == 0) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ count = LINE_GROUPS;
+ }
+ }
+
+ if (finish) {
+ // Finish up the tail of the input. Note that we need to
+ // consume any bytes in tail before any bytes
+ // remaining in input; there should be at most two bytes
+ // total.
+
+ if (p - tailLen == len - 1) {
+ int t = 0;
+ v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
+ tailLen -= t;
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (p - tailLen == len - 2) {
+ int t = 0;
+ v =
+ (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10)
+ | (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
+ tailLen -= t;
+ output[op++] = alphabet[(v >> 12) & 0x3f];
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (do_newline && op > 0 && count != LINE_GROUPS) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+
+ assert tailLen == 0;
+ assert p == len;
+ } else {
+ // Save the leftovers in tail to be consumed on the next
+ // call to encodeInternal.
+
+ if (p == len - 1) {
+ tail[tailLen++] = input[p];
+ } else if (p == len - 2) {
+ tail[tailLen++] = input[p];
+ tail[tailLen++] = input[p + 1];
+ }
+ }
+
+ this.op = op;
+ this.count = count;
+
+ return true;
+ }
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/CryptoUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/CryptoUtil.java
new file mode 100644
index 000000000..7918ad043
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/CryptoUtil.java
@@ -0,0 +1,61 @@
+package org.sunbird.auth.verifier;
+
+import java.nio.charset.Charset;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.SignatureException;
+import java.util.Map;
+import org.sunbird.logging.LoggerUtil;
+
+public class CryptoUtil {
+ private static final Charset US_ASCII = Charset.forName("US-ASCII");
+ private static final LoggerUtil logger = new LoggerUtil(CryptoUtil.class);
+
+ /**
+ * Verifies the RSA signature.
+ *
+ * @param payLoad The string payload.
+ * @param signature The signature bytes.
+ * @param key The public key.
+ * @param algorithm The signature algorithm (e.g., SHA256withRSA).
+ * @return True if verification succeeds, false otherwise.
+ */
+ public static boolean verifyRSASign(
+ String payLoad, byte[] signature, PublicKey key, String algorithm) {
+ return verifyRSASign(payLoad, signature, key, algorithm, null);
+ }
+
+ /**
+ * Verifies the RSA signature with logging context.
+ *
+ * @param payLoad The string payload.
+ * @param signature The signature bytes.
+ * @param key The public key.
+ * @param algorithm The signature algorithm.
+ * @param requestContext Context for logging (optional).
+ * @return True if verification succeeds, false otherwise.
+ */
+ public static boolean verifyRSASign(
+ String payLoad,
+ byte[] signature,
+ PublicKey key,
+ String algorithm,
+ Map requestContext) {
+ Signature sign;
+ try {
+ sign = Signature.getInstance(algorithm);
+ sign.initVerify(key);
+ sign.update(payLoad.getBytes(US_ASCII));
+ return sign.verify(signature);
+ } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
+ String msg = String.format("CryptoUtil:verifyRSASign: Exception occurred while token verification. Error: %s", e.getMessage());
+ if (requestContext != null) {
+ msg += ", Context: " + requestContext;
+ }
+ logger.error(msg, e);
+ return false;
+ }
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyData.java b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyData.java
similarity index 57%
rename from course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyData.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyData.java
index db6c33208..d4ed6e304 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyData.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyData.java
@@ -2,27 +2,51 @@
import java.security.PublicKey;
+/**
+ * Pojo for Key Data.
+ */
public class KeyData {
private String keyId;
private PublicKey publicKey;
+ /**
+ * Constructor
+ * @param keyId Key Id
+ * @param publicKey Public Key
+ */
public KeyData(String keyId, PublicKey publicKey) {
this.keyId = keyId;
this.publicKey = publicKey;
}
- public String getKeyId() {
+ /**
+ * Get Key Id
+ * @return keyId
+ */
+ public String getKeyId(){
return keyId;
}
+ /**
+ * Set Key Id
+ * @param keyId Key Id
+ */
public void setKeyId(String keyId) {
this.keyId = keyId;
}
+ /**
+ * Get Public Key
+ * @return publicKey
+ */
public PublicKey getPublicKey() {
return publicKey;
}
+ /**
+ * Set Public Key
+ * @param publicKey Public Key
+ */
public void setPublicKey(PublicKey publicKey) {
this.publicKey = publicKey;
}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyManager.java b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyManager.java
similarity index 57%
rename from course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyManager.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyManager.java
index ea3cd4ed8..667ef2429 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/auth-verifier/src/main/java/org/sunbird/auth/verifier/KeyManager.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/auth/verifier/KeyManager.java
@@ -1,12 +1,5 @@
package org.sunbird.auth.verifier;
-import org.sunbird.common.models.util.JsonKey;
-import org.sunbird.common.models.util.LoggerEnum;
-import org.sunbird.common.models.util.LoggerUtil;
-
-import org.sunbird.common.models.util.ProjectLogger;
-import org.sunbird.common.models.util.PropertiesCache;
-
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -19,56 +12,76 @@
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.common.PropertiesCache;
+/**
+ * Manages the loading and retrieval of Public Keys for token verification.
+ */
public class KeyManager {
- private static PropertiesCache propertiesCache = PropertiesCache.getInstance();
-
- private static Map keyMap = new HashMap();
- private static LoggerUtil logger = new LoggerUtil(KeyManager.class);
+ private static final LoggerUtil logger = new LoggerUtil(KeyManager.class);
+ private static final PropertiesCache propertiesCache = PropertiesCache.getInstance();
+ private static final Map keyMap = new HashMap<>();
+ /**
+ * Initializes the KeyManager by loading public keys from the configured base path.
+ */
public static void init() {
String basePath = propertiesCache.getProperty(JsonKey.ACCESS_TOKEN_PUBLICKEY_BASEPATH);
+ logger.info("KeyManager:init: Starting public key loading from base path: " + basePath);
+
try (Stream walk = Files.walk(Paths.get(basePath))) {
List result =
walk.filter(Files::isRegularFile).map(x -> x.toString()).collect(Collectors.toList());
+
result.forEach(
file -> {
try {
StringBuilder contentBuilder = new StringBuilder();
Path path = Paths.get(file);
Files.lines(path, StandardCharsets.UTF_8)
- .forEach(
- x -> {
- contentBuilder.append(x);
- });
+ .forEach(contentBuilder::append);
+
KeyData keyData =
new KeyData(
path.getFileName().toString(), loadPublicKey(contentBuilder.toString()));
keyMap.put(path.getFileName().toString(), keyData);
+ logger.info("KeyManager:init: Loaded key: " + path.getFileName().toString());
} catch (Exception e) {
- logger.error(null,"KeyManager:init: exception in reading public keys ", e);
+ logger.error("KeyManager:init: Exception in reading public key file: " + file, e);
}
});
} catch (Exception e) {
- logger.error(null,"KeyManager:init: exception in loading publickeys ", e);
+ logger.error("KeyManager:init: Exception in loading public keys base directory", e);
}
}
+ /**
+ * Retrieves the KeyData for a given Key ID.
+ * @param keyId The Key ID.
+ * @return The KeyData object, or null if not found.
+ */
public static KeyData getPublicKey(String keyId) {
return keyMap.get(keyId);
}
+ /**
+ * Parses a string representation of a public key into a PublicKey object.
+ * @param key The public key string (PEM format).
+ * @return The PublicKey object.
+ * @throws Exception If parsing fails.
+ */
public static PublicKey loadPublicKey(String key) throws Exception {
String publicKey = new String(key.getBytes(), StandardCharsets.UTF_8);
publicKey = publicKey.replaceAll("(-+BEGIN PUBLIC KEY-+)", "");
publicKey = publicKey.replaceAll("(-+END PUBLIC KEY-+)", "");
publicKey = publicKey.replaceAll("[\\r\\n]+", "");
- byte[] keyBytes = Base64Util.decode(publicKey.getBytes("UTF-8"), Base64Util.DEFAULT);
+ byte[] keyBytes = Base64Util.decode(publicKey.getBytes(StandardCharsets.UTF_8), Base64Util.DEFAULT);
X509EncodedKeySpec X509publicKey = new X509EncodedKeySpec(keyBytes);
KeyFactory kf = KeyFactory.getInstance("RSA");
return kf.generatePublic(X509publicKey);
}
-
}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/common/ProjectUtil.java
similarity index 84%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectUtil.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/common/ProjectUtil.java
index 748c33507..88ec29024 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectUtil.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/common/ProjectUtil.java
@@ -1,19 +1,9 @@
-package org.sunbird.common.models.util;
+package org.sunbird.common;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.i18n.phonenumbers.NumberParseException;
import com.google.i18n.phonenumbers.PhoneNumberUtil;
import com.google.i18n.phonenumbers.Phonenumber;
-import org.apache.commons.lang.StringUtils;
-import org.apache.commons.validator.UrlValidator;
-import org.apache.velocity.Template;
-import org.apache.velocity.VelocityContext;
-import org.apache.velocity.app.VelocityEngine;
-import org.sunbird.common.exception.ProjectCommonException;
-import org.sunbird.common.models.util.url.EsConfigUtil;
-import org.sunbird.common.request.Request;
-import org.sunbird.common.responsecode.ResponseCode;
-
import java.io.IOException;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
@@ -21,15 +11,38 @@
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Random;
+import java.util.TimeZone;
+import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.validator.UrlValidator;
+import org.apache.velocity.Template;
+import org.apache.velocity.VelocityContext;
+import org.apache.velocity.app.VelocityEngine;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.http.HttpUtil;
+import org.sunbird.utils.EsConfigUtil;
+import org.sunbird.request.Request;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
/**
- * This class will contains all the common utility methods.
+ * Utility class containing common methods and constants used across the project.
+ * Handles date formatting, email validation, ID generation, and configuration management.
*
* @author Manzarul
+ * @author Amit Kumar
*/
public class ProjectUtil {
@@ -80,7 +93,9 @@ public class ProjectUtil {
propertiesCache = PropertiesCache.getInstance();
}
- /** @author Manzarul */
+ /**
+ * Enumeration for Environment types.
+ */
public enum Environment {
dev(1),
qa(2),
@@ -96,7 +111,9 @@ public int getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for Status.
+ */
public enum Status {
ACTIVE(1),
INACTIVE(0);
@@ -112,6 +129,9 @@ public int getValue() {
}
}
+ /**
+ * Enumeration for Bulk Process Status.
+ */
public enum BulkProcessStatus {
NEW(0),
IN_PROGRESS(1),
@@ -130,6 +150,9 @@ public int getValue() {
}
}
+ /**
+ * Enumeration for Org Status.
+ */
public enum OrgStatus {
INACTIVE(0),
ACTIVE(1),
@@ -147,7 +170,9 @@ public Integer getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for Progress Status.
+ */
public enum ProgressStatus {
NOT_STARTED(0),
STARTED(1),
@@ -164,7 +189,9 @@ public int getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for Active Status.
+ */
public enum ActiveStatus {
ACTIVE(true),
INACTIVE(false);
@@ -180,6 +207,9 @@ public boolean getValue() {
}
}
+ /**
+ * Enumeration for Action.
+ */
public enum Action {
YES(1),
NO(0);
@@ -195,7 +225,9 @@ public int getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for Course Management Status.
+ */
public enum CourseMgmtStatus {
DRAFT("draft"),
LIVE("live"),
@@ -212,7 +244,9 @@ public String getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for Source.
+ */
public enum Source {
WEB("web"),
ANDROID("android"),
@@ -230,7 +264,9 @@ public String getValue() {
}
}
- /** @author Amit Kumar */
+ /**
+ * Enumeration for User Role.
+ */
public enum UserRole {
PUBLIC("PUBLIC"),
CONTENT_CREATOR("CONTENT_CREATOR"),
@@ -253,44 +289,46 @@ public String getValue() {
* This method will check incoming value is null or empty it will do empty check by doing trim
* method. in case of null or empty it will return true else false.
*
- * @param value
- * @return
+ * @param value String value to check
+ * @return boolean true if null or empty
*/
public static boolean isStringNullOREmpty(String value) {
return (value == null || "".equals(value.trim()));
}
/**
- * This method will provide formatted date
+ * This method will provide formatted date.
*
- * @return
+ * @return String formatted date
*/
public static String getFormattedDate() {
return getDateFormatter().format(new Date());
}
/**
- * This method will provide timestamp
+ * This method will provide timestamp.
*
- * @return
+ * @return Date current timestamp
*/
public static Date getTimeStamp() {
return new Timestamp(System.currentTimeMillis());
}
/**
- * This method will provide formatted date
+ * This method will provide formatted date.
*
- * @return
+ * @param date Date object
+ * @return String formatted date
*/
public static String formatDate(Date date) {
if (null != date) return getDateFormatter().format(date);
else return null;
}
+
/**
- * Validate email with regular expression
+ * Validate email with regular expression.
*
- * @param email
+ * @param email String email
* @return true valid email, false invalid email
*/
public static boolean isEmailvalid(final String email) {
@@ -302,11 +340,11 @@ public static boolean isEmailvalid(final String email) {
}
/**
- * This method will generate auth token based on name , source and timestamp
+ * This method will generate auth token based on name , source and timestamp.
*
- * @param name String
- * @param source String
- * @return String
+ * @param name String name
+ * @param source String source
+ * @return String auth token
*/
public static String createAuthToken(String name, String source) {
String data = name + source + System.currentTimeMillis();
@@ -317,8 +355,8 @@ public static String createAuthToken(String name, String source) {
/**
* This method will generate unique id based on current time stamp and some random value mixed up.
*
- * @param environmentId int
- * @return String
+ * @param environmentId int environment id
+ * @return String unique id
*/
public static String getUniqueIdFromTimestamp(int environmentId) {
Random random = new Random();
@@ -329,14 +367,17 @@ public static String getUniqueIdFromTimestamp(int environmentId) {
}
/**
- * This method will generate the unique id .
+ * This method will generate the unique id.
*
- * @return
+ * @return String unique id
*/
public static synchronized String generateUniqueId() {
return UUID.randomUUID().toString();
}
+ /**
+ * Enumeration for HTTP Methods.
+ */
public enum Method {
GET,
POST,
@@ -347,8 +388,6 @@ public enum Method {
/**
* Enum to hold the index name for Elastic search.
- *
- * @author Manzarul
*/
public enum EsIndex {
sunbird("searchindex"),
@@ -367,8 +406,6 @@ public String getIndexName() {
/**
* This enum will hold all the ES type name.
- *
- * @author Manzarul
*/
public enum EsType {
course(EsConfigUtil.getConfigValue(JsonKey.ES_COURSE_INDEX)),
@@ -388,6 +425,9 @@ public String getTypeName() {
}
}
+ /**
+ * Enumeration for Section Data Type.
+ */
public enum SectionDataType {
course("course"),
content("content");
@@ -402,6 +442,9 @@ public String getTypeName() {
}
}
+ /**
+ * Enumeration for Address Type.
+ */
public enum AddressType {
permanent("permanent"),
current("current"),
@@ -418,6 +461,9 @@ public String getTypeName() {
}
}
+ /**
+ * Enumeration for Assessment Result.
+ */
public enum AssessmentResult {
gradeA("A", "Pass"),
gradeB("B", "Pass"),
@@ -443,11 +489,11 @@ public String getResult() {
}
/**
- * This method will calculate the percentage
+ * This method will calculate the percentage.
*
- * @param score double
- * @param maxScore double
- * @return double
+ * @param score double score
+ * @param maxScore double max score
+ * @return double percentage
*/
public static double calculatePercentage(double score, double maxScore) {
double percentage = (score * 100) / (maxScore * 1.0);
@@ -457,7 +503,7 @@ public static double calculatePercentage(double score, double maxScore) {
/**
* This method will calculate grade based on percentage marks.
*
- * @param percentage double
+ * @param percentage double percentage
* @return AssessmentResult
*/
public static AssessmentResult calcualteAssessmentResult(double percentage) {
@@ -479,28 +525,61 @@ public static AssessmentResult calcualteAssessmentResult(double percentage) {
}
}
+ /**
+ * Checks if object is null.
+ *
+ * @param obj Object
+ * @return boolean true if null
+ */
public static boolean isNull(Object obj) {
return null == obj ? true : false;
}
+ /**
+ * Checks if object is not null.
+ *
+ * @param obj Object
+ * @return boolean true if not null
+ */
public static boolean isNotNull(Object obj) {
return null != obj ? true : false;
}
+ /**
+ * Formats message with values.
+ *
+ * @param exceptionMsg String message pattern
+ * @param fieldValue Object... values
+ * @return String formatted message
+ */
public static String formatMessage(String exceptionMsg, Object... fieldValue) {
return MessageFormat.format(exceptionMsg, fieldValue);
}
+ /**
+ * Gets default date formatter.
+ *
+ * @return SimpleDateFormat
+ */
public static SimpleDateFormat getDateFormatter() {
return getDateFormatter("yyyy-MM-dd HH:mm:ss:SSSZ");
}
+ /**
+ * Gets date formatter for pattern.
+ *
+ * @param pattern String pattern
+ * @return SimpleDateFormat
+ */
public static SimpleDateFormat getDateFormatter(String pattern) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
simpleDateFormat.setLenient(false);
return simpleDateFormat;
}
- /** @author Manzarul */
+
+ /**
+ * Enumeration for Enrolment Type.
+ */
public enum EnrolmentType {
open("open"),
inviteOnly("invite-only");
@@ -515,6 +594,12 @@ public String getVal() {
}
}
+ /**
+ * Gets Velocity Context from map.
+ *
+ * @param map Map data
+ * @return VelocityContext
+ */
public static VelocityContext getContext(Map map) {
propertiesCache = PropertiesCache.getInstance();
VelocityContext context = new VelocityContext();
@@ -605,7 +690,9 @@ private static Object getValue(Map map, String key) {
return value;
}
- /** @author Arvind */
+ /**
+ * Enumeration for Report Tracking Status.
+ */
public enum ReportTrackingStatus {
NEW(0),
GENERATING_DATA(1),
@@ -626,6 +713,14 @@ public int getValue() {
}
}
+ /**
+ * Creates health check response.
+ *
+ * @param serviceName String service name
+ * @param isError boolean is error
+ * @param e Exception
+ * @return Map response
+ */
public static Map createCheckResponse(
String serviceName, boolean isError, Exception e) {
Map responseMap = new HashMap<>();
@@ -654,8 +749,8 @@ public static Map createCheckResponse(
* @param tagId String unique tag id.
* @param body String requested body
* @param header Map
- * @return String
- * @throws IOException
+ * @return String tag status
+ * @throws Exception if error occurs
*/
public static String registertag(String tagId, String body, Map header)
throws Exception {
@@ -679,6 +774,9 @@ public static String registertag(String tagId, String body, Map
return tagStatus;
}
+ /**
+ * Enumeration for Object Types.
+ */
public enum ObjectTypes {
user("user"),
organisation("organisation"),
@@ -695,6 +793,11 @@ public String getValue() {
}
}
+ /**
+ * Generates random password.
+ *
+ * @return String random password
+ */
public static String generateRandomPassword() {
String SALTCHARS = "abcdef12345ghijklACDEFGHmnopqrs67IJKLMNOP890tuvQRSTUwxyzVWXYZ";
StringBuilder salt = new StringBuilder();
@@ -708,10 +811,10 @@ public static String generateRandomPassword() {
}
/**
- * This method will do the phone number validation check
+ * This method will do the phone number validation check.
*
- * @param phone String
- * @return boolean
+ * @param phone String phone number
+ * @return boolean true if valid
*/
public static boolean validatePhoneNumber(String phone) {
String phoneNo = "";
@@ -722,6 +825,11 @@ public static boolean validatePhoneNumber(String phone) {
else return (phoneNo.matches("\\(\\d{3}\\)-\\d{3}-\\d{4}"));
}
+ /**
+ * Gets Ekstep header map.
+ *
+ * @return Map headers
+ */
public static Map getEkstepHeader() {
Map headerMap = new HashMap<>();
String header = System.getenv(JsonKey.EKSTEP_AUTHORIZATION);
@@ -735,6 +843,13 @@ public static Map getEkstepHeader() {
return headerMap;
}
+ /**
+ * Validates phone number with country code.
+ *
+ * @param phNumber String phone number
+ * @param countryCode String country code
+ * @return boolean true if valid
+ */
public static boolean validatePhone(String phNumber, String countryCode) {
PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
String contryCode = countryCode;
@@ -756,6 +871,12 @@ public static boolean validatePhone(String phNumber, String countryCode) {
return false;
}
+ /**
+ * Validates country code.
+ *
+ * @param countryCode String country code
+ * @return boolean true if valid
+ */
public static boolean validateCountryCode(String countryCode) {
String pattern = "^(?:[+] ?){0,1}(?:[0-9] ?){1,3}";
try {
@@ -767,6 +888,12 @@ public static boolean validateCountryCode(String countryCode) {
}
}
+ /**
+ * Generates SMS body from template.
+ *
+ * @param smsTemplate Map template data
+ * @return String SMS body
+ */
public static String getSMSBody(Map smsTemplate) {
try {
Properties props = new Properties();
@@ -794,6 +921,13 @@ public static String getSMSBody(Map smsTemplate) {
return "";
}
+ /**
+ * Checks if date is valid format.
+ *
+ * @param format String date format
+ * @param value String date value
+ * @return boolean true if valid
+ */
public static boolean isDateValidFormat(String format, String value) {
Date date = null;
try {
@@ -808,7 +942,9 @@ public static boolean isDateValidFormat(String format, String value) {
return date != null;
}
- /** This method will create a new ProjectCommonException of type server Error and throws it. */
+ /**
+ * This method will create a new ProjectCommonException of type server Error and throws it.
+ */
public static void createAndThrowServerError() {
throw new ProjectCommonException(
ResponseCode.SERVER_ERROR.getErrorCode(),
@@ -851,6 +987,12 @@ public static boolean isUrlvalid(String url) {
return urlValidator.isValid(url);
}
+ /**
+ * Gets config value from env or properties.
+ *
+ * @param key String key
+ * @return String value
+ */
public static String getConfigValue(String key) {
if (StringUtils.isNotBlank(System.getenv(key))) {
return System.getenv(key);
@@ -859,9 +1001,9 @@ public static String getConfigValue(String key) {
}
/**
- * This method will create index for Elastic search as follow "telemetry.raw.yyyy.mm"
+ * This method will create index for Elastic search as follow "telemetry.raw.yyyy.mm".
*
- * @return
+ * @return String index name
*/
public static String createIndex() {
Calendar cal = Calendar.getInstance();
@@ -877,7 +1019,7 @@ public static String createIndex() {
}
/**
- * This method will check whether Array contains only empty string or not
+ * This method will check whether Array contains only empty string or not.
*
* @param strArray String[]
* @return boolean
@@ -901,7 +1043,7 @@ public static String convertMapToJsonString(List> mapList) {
try {
return mapper.writeValueAsString(mapList);
} catch (IOException e) {
- logger.error(null, e.getMessage(), e);
+ logger.error(null, e.getMessage(), e);
}
return null;
}
@@ -970,7 +1112,7 @@ public static Map getDateRange(int numDays) {
* This method will be used to create ProjectCommonException for all kind of client error for the
* given response code(enum).
*
- * @param : An enum of all the api responses.
+ * @param responseCode An enum of all the api responses.
* @return ProjectCommonException
*/
public static ProjectCommonException createClientException(ResponseCode responseCode) {
@@ -980,6 +1122,12 @@ public static ProjectCommonException createClientException(ResponseCode response
ResponseCode.CLIENT_ERROR.getResponseCode());
}
+ /**
+ * Gets LMS User ID from federated ID.
+ *
+ * @param fedUserId String federated user id
+ * @return String user id
+ */
public static String getLmsUserId(String fedUserId) {
String userId = fedUserId;
String prefix =
@@ -990,11 +1138,18 @@ public static String getLmsUserId(String fedUserId) {
return userId;
}
+ /**
+ * Gets first N characters of string.
+ *
+ * @param originalText String original text
+ * @param noOfChar int number of characters
+ * @return String first N characters
+ */
public static String getFirstNCharacterString(String originalText, int noOfChar) {
+ String firstNChars = "";
if (StringUtils.isBlank(originalText)) {
return "";
}
- String firstNChars = "";
if (originalText.length() > noOfChar) {
firstNChars = originalText.substring(0, noOfChar);
} else {
@@ -1003,6 +1158,9 @@ public static String getFirstNCharacterString(String originalText, int noOfChar)
return firstNChars;
}
+ /**
+ * Enumeration for Migrate Action.
+ */
public enum MigrateAction {
ACCEPT("accept"),
REJECT("reject");
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/common/PropertiesCache.java b/core/sunbird-platform-common/src/main/java/org/sunbird/common/PropertiesCache.java
new file mode 100644
index 000000000..e2fde9253
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/common/PropertiesCache.java
@@ -0,0 +1,148 @@
+package org.sunbird.common;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.logging.LoggerUtil;
+
+/**
+ * Singleton class to load and manage application configuration properties.
+ * Reads attributes from multiple property files and provides access validation/defaults.
+ *
+ * @author Amit Kumar
+ */
+public class PropertiesCache {
+
+ private static final LoggerUtil logger = new LoggerUtil(PropertiesCache.class);
+ private final String[] fileName = {
+ "elasticsearch.config.properties",
+ "cassandra.config.properties",
+ "dbconfig.properties",
+ "externalresource.properties",
+ "sso.properties",
+ "userencryption.properties",
+ "profilecompleteness.properties",
+ "mailTemplates.properties"
+ };
+ private final Properties configProp = new Properties();
+ public final Map attributePercentageMap = new ConcurrentHashMap<>();
+ private static volatile PropertiesCache propertiesCache = null;
+
+ /**
+ * Private constructor to load properties from files.
+ * Also initializes weighted attributes for profile completeness.
+ */
+ private PropertiesCache() {
+ for (String file : fileName) {
+ try (InputStream in = this.getClass().getClassLoader().getResourceAsStream(file)) {
+ if (in != null) {
+ configProp.load(in);
+ } else {
+ logger.warn("PropertiesCache: Configuration file not found: " + file, null);
+ }
+ } catch (IOException e) {
+ logger.error("PropertiesCache: Error loading file: " + file, e);
+ }
+ }
+ loadWeighted();
+ }
+
+ /**
+ * Returns the singleton instance of PropertiesCache.
+ * Uses double-checked locking for thread safety.
+ *
+ * @return The singleton PropertiesCache instance.
+ */
+ public static PropertiesCache getInstance() {
+ if (propertiesCache == null) {
+ synchronized (PropertiesCache.class) {
+ if (propertiesCache == null) {
+ propertiesCache = new PropertiesCache();
+ }
+ }
+ }
+ return propertiesCache;
+ }
+
+ /**
+ * Saves or updates a configuration property in memory.
+ *
+ * @param key The property key.
+ * @param value The property value.
+ */
+ public void saveConfigProperty(String key, String value) {
+ configProp.setProperty(key, value);
+ }
+
+ /**
+ * Retrieves a property value.
+ * Checks system environment variables first, then the loaded properties.
+ * If the value is not found in properties, returns the key itself.
+ *
+ * @param key The property key to look up.
+ * @return The property value or the key if not found.
+ */
+ public String getProperty(String key) {
+ String value = System.getenv(key);
+ if (StringUtils.isNotBlank(value)) {
+ return value;
+ }
+ return configProp.getProperty(key) != null ? configProp.getProperty(key) : key;
+ }
+
+ /**
+ * Loads weighted attributes for user profile completeness from configuration.
+ * Parses 'user.profile.attribute' and 'user.profile.weighted' properties.
+ */
+ private void loadWeighted() {
+ String key = configProp.getProperty("user.profile.attribute");
+ String value = configProp.getProperty("user.profile.weighted");
+
+ if (StringUtils.isBlank(key)) {
+ logger.info("PropertiesCache:loadWeighted: Profile completeness value is not set.");
+ return;
+ }
+
+ String[] keys = key.split(",");
+
+ if (StringUtils.isNotBlank(value)) {
+ String[] values = value.split(",");
+ if (keys.length == values.length) {
+ logger.info("PropertiesCache:loadWeighted: Weighted value is provided by user.");
+ for (int i = 0; i < keys.length; i++) {
+ try {
+ attributePercentageMap.put(keys[i], Float.valueOf(values[i]));
+ } catch (NumberFormatException e) {
+ logger.error("PropertiesCache:loadWeighted: Invalid float value for key: " + keys[i], e);
+ }
+ }
+ return;
+ }
+ }
+
+ // Fallback: equally divide weight if values are missing or mismatched
+ logger.info("PropertiesCache:loadWeighted: Weighted value is not provided or mismatched. Distributing equally.");
+ float perc = 100.0f / keys.length;
+ for (String k : keys) {
+ attributePercentageMap.put(k, perc);
+ }
+ }
+
+ /**
+ * Reads a property value from system environment or loaded properties.
+ * Unlike getProperty, this returns null if key is not found (instead of returning the key).
+ *
+ * @param key The property key.
+ * @return The property value, or null if not found.
+ */
+ public String readProperty(String key) {
+ String value = System.getenv(key);
+ if (StringUtils.isNotBlank(value)) {
+ return value;
+ }
+ return configProp.getProperty(key);
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DataMaskingService.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DataMaskingService.java
new file mode 100644
index 000000000..7415c48d4
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DataMaskingService.java
@@ -0,0 +1,78 @@
+/** */
+package org.sunbird.datasecurity;
+
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.keys.JsonKey;
+
+/**
+ * Service interface for masking sensitive data such as phone numbers, emails, and OTPs.
+ * Provides default implementations for generic data and OTP masking.
+ */
+public interface DataMaskingService {
+
+
+ /**
+ * Checks if the given data string contains masked characters (asterisks).
+ *
+ * @param data The string to check.
+ * @return true if the data contains an asterisk, false otherwise.
+ */
+ default boolean isMasked(String data) {
+ return data.contains(JsonKey.REPLACE_WITH_ASTERISK);
+ }
+
+ /**
+ * Masks a phone number.
+ *
+ * @param phone The phone number to mask.
+ * @return The masked phone number.
+ */
+ String maskPhone(String phone);
+
+ /**
+ * Masks an email address.
+ *
+ * @param email The email address to mask.
+ * @return The masked email address.
+ */
+ String maskEmail(String email);
+
+ /**
+ * Masks generic data strings.
+ * If the data is blank or has a length of 3 or less, it is returned as is.
+ * Otherwise, it masks characters with asterisks, leaving the last 4 characters visible.
+ *
+ * @param data The data string to mask.
+ * @return The masked data string.
+ */
+ default String maskData(String data) {
+ if (StringUtils.isBlank(data) || data.length() <= 3) {
+ return data;
+ }
+ int lenght = data.length() - 4;
+ StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < data.length(); i++) {
+ if (i < lenght) {
+ builder.append(JsonKey.REPLACE_WITH_ASTERISK);
+ } else {
+ builder.append(data.charAt(i));
+ }
+ }
+ return builder.toString();
+ }
+
+ /**
+ * Masks an OTP (One Time Password).
+ * Depending on the length (>= 6 or < 6), it masks all but the first 4 or 2 characters respectively.
+ *
+ * @param otp The OTP string to mask.
+ * @return The masked OTP string.
+ */
+ default String maskOTP(String otp) {
+ if (otp.length() >= 6) {
+ return otp.replaceAll("(^[^*]{4}|(?!^)\\G)[^*]", "$1*");
+ } else {
+ return otp.replaceAll("(^[^*]{2}|(?!^)\\G)[^*]", "$1*");
+ }
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DecryptionService.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DecryptionService.java
new file mode 100644
index 000000000..80330c808
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/DecryptionService.java
@@ -0,0 +1,98 @@
+package org.sunbird.datasecurity;
+
+import java.util.List;
+import java.util.Map;
+import org.sunbird.request.RequestContext;
+
+/**
+ * This service will have data decryption methods. Encryption logic will differ based on implementation classes.
+ */
+public interface DecryptionService {
+
+ String ALGORITHM = "AES";
+ int ITERATIONS = 3;
+ byte[] keyValue =
+ new byte[] {'T', 'h', 'i', 's', 'A', 's', 'I', 'S', 'e', 'r', 'c', 'e', 'K', 't', 'e', 'y'};
+
+ /**
+ * Decrypts the given data map. Values can be primitives, Strings, or nested Maps.
+ *
+ * @param data The map containing data to decrypt.
+ * @param context The request context.
+ * @return The map with decrypted values.
+ */
+ Map decryptData(Map data, RequestContext context);
+
+ /**
+ * Decrypts the given data map. Values can be primitives, Strings, or nested Maps.
+ * Default implementation calls decryptData(data, null).
+ *
+ * @param data The map containing data to decrypt.
+ * @return The map with decrypted values.
+ */
+ default Map decryptData(Map data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts a list of data maps.
+ *
+ * @param data The list of maps to decrypt.
+ * @param context The request context.
+ * @return The list of maps with decrypted values.
+ */
+ List> decryptData(List> data, RequestContext context);
+
+ /**
+ * Decrypts a list of data maps.
+ * Default implementation calls decryptData(data, null).
+ *
+ * @param data The list of maps to decrypt.
+ * @return The list of maps with decrypted values.
+ */
+ default List> decryptData(List> data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts the given string data.
+ *
+ * @param data The string to decrypt.
+ * @param context The request context.
+ * @return The decrypted string.
+ */
+ String decryptData(String data, RequestContext context);
+
+ /**
+ * Decrypts the given string data.
+ * Default implementation calls decryptData(data, null).
+ *
+ * @param data The string to decrypt.
+ * @return The decrypted string.
+ */
+ default String decryptData(String data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts the given string data with an option to throw an exception on failure.
+ *
+ * @param data The string to decrypt.
+ * @param throwExceptionOnFailure Whether to throw an exception if decryption fails.
+ * @param context The request context.
+ * @return The decrypted string.
+ */
+ String decryptData(String data, boolean throwExceptionOnFailure, RequestContext context);
+
+ /**
+ * Decrypts the given string data with an option to throw an exception on failure.
+ * Default implementation calls decryptData(data, throwExceptionOnFailure, null).
+ *
+ * @param data The string to decrypt.
+ * @param throwExceptionOnFailure Whether to throw an exception if decryption fails.
+ * @return The decrypted string.
+ */
+ default String decryptData(String data, boolean throwExceptionOnFailure) {
+ return decryptData(data, throwExceptionOnFailure, null);
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/EncryptionService.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/EncryptionService.java
new file mode 100644
index 000000000..a053082e9
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/EncryptionService.java
@@ -0,0 +1,83 @@
+package org.sunbird.datasecurity;
+
+import java.util.List;
+import java.util.Map;
+import org.sunbird.request.RequestContext;
+
+/**
+ * Service interface for data encryption operations.
+ * Implementations provide specific encryption logic.
+ */
+public interface EncryptionService {
+
+ String ALGORITHM = "AES";
+ int ITERATIONS = 3;
+ byte[] keyValue =
+ new byte[] {'T', 'h', 'i', 's', 'A', 's', 'I', 'S', 'e', 'r', 'c', 'e', 'K', 't', 'e', 'y'};
+
+ /**
+ * Encrypts the values in a map.
+ *
+ * @param data The map containing data to encrypt.
+ * @param context The request context.
+ * @return The map with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ Map encryptData(Map data, RequestContext context);
+
+ /**
+ * Encrypts the values in a map without a request context.
+ * Delegates to {@link #encryptData(Map, RequestContext)} with null context.
+ *
+ * @param data The map containing data to encrypt.
+ * @return The map with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ default Map encryptData(Map data) throws Exception {
+ return encryptData(data, null);
+ }
+
+ /**
+ * Encrypts the values in a list of maps.
+ *
+ * @param data The list of maps to encrypt.
+ * @param context The request context.
+ * @return The list of maps with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ List> encryptData(List> data, RequestContext context);
+
+ /**
+ * Encrypts the values in a list of maps without a request context.
+ * Delegates to {@link #encryptData(List, RequestContext)} with null context.
+ *
+ * @param data The list of maps to encrypt.
+ * @return The list of maps with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ default List> encryptData(List> data) throws Exception {
+ return encryptData(data, null);
+ }
+
+ /**
+ * Encrypts a single string value.
+ *
+ * @param data The string to encrypt.
+ * @param context The request context.
+ * @return The encrypted string.
+ * @throws Exception If an error occurs during encryption.
+ */
+ String encryptData(String data, RequestContext context);
+
+ /**
+ * Encrypts a single string value without a request context.
+ * Delegates to {@link #encryptData(String, RequestContext)} with null context.
+ *
+ * @param data The string to encrypt.
+ * @return The encrypted string.
+ * @throws Exception If an error occurs during encryption.
+ */
+ default String encryptData(String data) throws Exception {
+ return encryptData(data, null);
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/OneWayHashing.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/OneWayHashing.java
new file mode 100644
index 000000000..c853e0480
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/OneWayHashing.java
@@ -0,0 +1,39 @@
+package org.sunbird.datasecurity;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import org.sunbird.logging.LoggerUtil;
+
+/**
+ * Utility class for performing one-way data hashing.
+ * Uses SHA-256 algorithm to hash input strings.
+ */
+public class OneWayHashing {
+
+ public static LoggerUtil logger = new LoggerUtil(OneWayHashing.class);
+
+ private OneWayHashing() {}
+
+ /**
+ * Encrypts (hashes) a value using SHA-256 algorithm.
+ *
+ * @param val The string value to hash.
+ * @return The SHA-256 hash of the value in hexadecimal format, or an empty string if an error occurs.
+ */
+ public static String encryptVal(String val) {
+ try {
+ MessageDigest md = MessageDigest.getInstance("SHA-256");
+ md.update(val.getBytes(StandardCharsets.UTF_8));
+ byte[] byteData = md.digest();
+ // convert the byte to hex format
+ StringBuilder sb = new StringBuilder();
+ for (byte b : byteData) {
+ sb.append(Integer.toString((b & 0xff) + 0x100, 16).substring(1));
+ }
+ return sb.toString();
+ } catch (Exception e) {
+ logger.error("Error while encrypting", e);
+ }
+ return "";
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Decoder.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Decoder.java
new file mode 100644
index 000000000..5363aefed
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Decoder.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.sunbird.datasecurity.impl;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+
+/**
+ * This class implements a BASE64 Character decoder as specified in RFC1521.
+ *
+ *
This RFC is part of the MIME specification which is published by the Internet Engineering Task
+ * Force (IETF). Unlike some other encoding schemes there is nothing in this encoding that tells the
+ * decoder where a buffer starts or stops, so to use it you will need to isolate your encoded data
+ * into a single chunk and then feed them this decoder. The simplest way to do that is to read all
+ * of the encoded data into a string and then use:
+ *
+ *
+ *
+ * This will decode the String in bufferString and give you an array of bytes in the array
+ * myData.
+ *
+ *
On errors, this class throws a CEFormatException with the following detail strings:
+ *
+ *
+ * "BASE64Decoder: Not enough bytes for an atom."
+ *
+ *
+ * @author Chuck McManis
+ * @see CharacterEncoder
+ * @see BASE64Decoder
+ */
+public class BASE64Decoder extends CharacterDecoder {
+ /**
+ * This class has 4 bytes per atom
+ *
+ * @return 4
+ */
+ protected int bytesPerAtom() {
+ return (4);
+ }
+
+ /**
+ * Any multiple of 4 will do, 72 might be common
+ *
+ * @return 72
+ */
+ protected int bytesPerLine() {
+ return (72);
+ }
+
+ /** This character array provides the character to value map based on RFC1521. */
+ private static final char pem_array[] = {
+ // 0 1 2 3 4 5 6 7
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', // 0
+ 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', // 1
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', // 2
+ 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', // 3
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', // 4
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', // 5
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', // 6
+ '4', '5', '6', '7', '8', '9', '+', '/' // 7
+ };
+
+ private static final byte pem_convert_array[] = new byte[256];
+
+ static {
+ for (int i = 0; i < 255; i++) {
+ pem_convert_array[i] = -1;
+ }
+ for (int i = 0; i < pem_array.length; i++) {
+ pem_convert_array[pem_array[i]] = (byte) i;
+ }
+ }
+
+ byte decode_buffer[] = new byte[4];
+
+ /**
+ * Decode one BASE64 atom into 1, 2, or 3 bytes of data.
+ *
+ * @param inStream The input stream to read the data from.
+ * @param outStream The output stream to write the decoded data to.
+ * @param rem The number of bytes to decode.
+ * @throws java.io.IOException If an I/O error occurs.
+ */
+ @SuppressWarnings("fallthrough")
+ protected void decodeAtom(PushbackInputStream inStream, OutputStream outStream, int rem)
+ throws java.io.IOException {
+ int i;
+ byte a = -1, b = -1, c = -1, d = -1;
+
+ if (rem < 2) {
+ throw new IOException("BASE64Decoder: Not enough bytes for an atom.");
+ }
+ do {
+ i = inStream.read();
+ if (i == -1) {
+ throw new IOException();
+ }
+ } while (i == '\n' || i == '\r');
+ decode_buffer[0] = (byte) i;
+
+ i = readFully(inStream, decode_buffer, 1, rem - 1);
+ if (i == -1) {
+ throw new IOException();
+ }
+
+ if (rem > 3 && decode_buffer[3] == '=') {
+ rem = 3;
+ }
+ if (rem > 2 && decode_buffer[2] == '=') {
+ rem = 2;
+ }
+ switch (rem) {
+ case 4:
+ d = pem_convert_array[decode_buffer[3] & 0xff];
+ // NOBREAK
+ case 3:
+ c = pem_convert_array[decode_buffer[2] & 0xff];
+ // NOBREAK
+ case 2:
+ b = pem_convert_array[decode_buffer[1] & 0xff];
+ a = pem_convert_array[decode_buffer[0] & 0xff];
+ break;
+ }
+
+ switch (rem) {
+ case 2:
+ outStream.write((byte) (((a << 2) & 0xfc) | ((b >>> 4) & 3)));
+ break;
+ case 3:
+ outStream.write((byte) (((a << 2) & 0xfc) | ((b >>> 4) & 3)));
+ outStream.write((byte) (((b << 4) & 0xf0) | ((c >>> 2) & 0xf)));
+ break;
+ case 4:
+ outStream.write((byte) (((a << 2) & 0xfc) | ((b >>> 4) & 3)));
+ outStream.write((byte) (((b << 4) & 0xf0) | ((c >>> 2) & 0xf)));
+ outStream.write((byte) (((c << 6) & 0xc0) | (d & 0x3f)));
+ break;
+ }
+ return;
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Encoder.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Encoder.java
new file mode 100644
index 000000000..73569e2b0
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/BASE64Encoder.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.sunbird.datasecurity.impl;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * This class implements a BASE64 Character encoder as specified in RFC1521. This RFC is part of the
+ * MIME specification as published by the Internet Engineering Task Force (IETF). Unlike some other
+ * encoding schemes there is nothing in this encoding that indicates where a buffer starts or ends.
+ *
+ *
This means that the encoded text will simply start with the first line of encoded text and end
+ * with the last line of encoded text.
+ *
+ * @author Chuck McManis
+ * @see CharacterEncoder
+ * @see BASE64Decoder
+ */
+public class BASE64Encoder extends CharacterEncoder {
+ /**
+ * this class encodes three bytes per atom.
+ *
+ * @return 3
+ */
+ protected int bytesPerAtom() {
+ return (3);
+ }
+
+ /**
+ * this class encodes 57 bytes per line. This results in a maximum of 57/3 * 4 or 76 characters
+ * per output line. Not counting the line termination.
+ *
+ * @return 57
+ */
+ protected int bytesPerLine() {
+ return (57);
+ }
+
+ /** This array maps the characters to their 6 bit values */
+ private static final char pem_array[] = {
+ // 0 1 2 3 4 5 6 7
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', // 0
+ 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', // 1
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', // 2
+ 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', // 3
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', // 4
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', // 5
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', // 6
+ '4', '5', '6', '7', '8', '9', '+', '/' // 7
+ };
+
+ /**
+ * encodeAtom - Take three bytes of input and encode it as 4 printable characters. Note that if
+ * the length in len is less than three is encodes either one or two '=' signs to indicate padding
+ * characters.
+ *
+ * @param outStream The output stream to write the encoded data to.
+ * @param data The input buffer containing the data.
+ * @param offset The offset in the buffer to start reading.
+ * @param len The number of bytes to encode.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void encodeAtom(OutputStream outStream, byte data[], int offset, int len)
+ throws IOException {
+ byte a, b, c;
+
+ if (len == 1) {
+ a = data[offset];
+ b = 0;
+ c = 0;
+ outStream.write(pem_array[(a >>> 2) & 0x3F]);
+ outStream.write(pem_array[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
+ outStream.write('=');
+ outStream.write('=');
+ } else if (len == 2) {
+ a = data[offset];
+ b = data[offset + 1];
+ c = 0;
+ outStream.write(pem_array[(a >>> 2) & 0x3F]);
+ outStream.write(pem_array[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
+ outStream.write(pem_array[((b << 2) & 0x3c) + ((c >>> 6) & 0x3)]);
+ outStream.write('=');
+ } else {
+ a = data[offset];
+ b = data[offset + 1];
+ c = data[offset + 2];
+ outStream.write(pem_array[(a >>> 2) & 0x3F]);
+ outStream.write(pem_array[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
+ outStream.write(pem_array[((b << 2) & 0x3c) + ((c >>> 6) & 0x3)]);
+ outStream.write(pem_array[c & 0x3F]);
+ }
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterDecoder.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterDecoder.java
new file mode 100644
index 000000000..0c2775ea1
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterDecoder.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package org.sunbird.datasecurity.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * This class defines the decoding half of character encoders. A character decoder is an algorithim
+ * for transforming 8 bit binary data that has been encoded into text by a character encoder, back
+ * into original binary form.
+ *
+ *
The character encoders, in general, have been structured around a central theme that binary
+ * data can be encoded into text that has the form:
+ *
+ *
+ *
+ * Of course in the simplest encoding schemes, the buffer has no distinct prefix of suffix, however
+ * all have some fixed relationship between the text in an 'atom' and the binary data itself.
+ *
+ *
In the CharacterEncoder and CharacterDecoder classes, one complete chunk of data is referred
+ * to as a buffer. Encoded buffers are all text, and decoded buffers (sometimes just referred
+ * to as buffers) are binary octets.
+ *
+ *
To create a custom decoder, you must, at a minimum, overide three abstract methods in this
+ * class.
+ *
+ *
+ *
bytesPerAtom which tells the decoder how many bytes to expect from decodeAtom
+ *
decodeAtom which decodes the bytes sent to it as text.
+ *
bytesPerLine which tells the encoder the maximum number of bytes per line.
+ *
+ *
+ * In general, the character decoders return error in the form of a CEFormatException. The syntax of
+ * the detail string is
+ *
+ *
+ * DecoderClassName: Error message.
+ *
+ *
+ * Several useful decoders have already been written and are referenced in the See Also list below.
+ *
+ * @author Chuck McManis
+ * @see CharacterEncoder
+ * @see BASE64Decoder
+ */
+public abstract class CharacterDecoder {
+ public CharacterDecoder() {}
+ /**
+ * Return the number of bytes per atom of decoding
+ *
+ * @return The number of bytes per atom.
+ */
+ protected abstract int bytesPerAtom();
+
+ /**
+ * Return the maximum number of bytes that can be encoded per line
+ *
+ * @return The maximum number of bytes per line.
+ */
+ protected abstract int bytesPerLine();
+
+ /**
+ * decode the beginning of the buffer, by default this is a NOP.
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void decodeBufferPrefix(PushbackInputStream aStream, OutputStream bStream)
+ throws IOException {}
+
+ /**
+ * decode the buffer suffix, again by default it is a NOP.
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void decodeBufferSuffix(PushbackInputStream aStream, OutputStream bStream)
+ throws IOException {}
+
+ /**
+ * This method should return, if it knows, the number of bytes that will be decoded. Many formats
+ * such as uuencoding provide this information. By default we return the maximum bytes that could
+ * have been encoded on the line.
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @return The expected number of bytes.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected int decodeLinePrefix(PushbackInputStream aStream, OutputStream bStream)
+ throws IOException {
+ return (bytesPerLine());
+ }
+
+ /**
+ * This method post processes the line, if there are error detection or correction codes in a
+ * line, they are generally processed by this method. The simplest version of this method looks
+ * for the (newline) character.
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void decodeLineSuffix(PushbackInputStream aStream, OutputStream bStream)
+ throws IOException {}
+
+ /**
+ * This method does an actual decode. It takes the decoded bytes and writes them to the
+ * OutputStream. The integer l tells the method how many bytes are required. This is always
+ * <= bytesPerAtom().
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @param l The number of bytes to decode.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void decodeAtom(PushbackInputStream aStream, OutputStream bStream, int l)
+ throws IOException {
+ throw new IOException();
+ }
+
+ /**
+ * This method works around the bizarre semantics of BufferedInputStream's read method.
+ *
+ * @param in The input stream.
+ * @param buffer The buffer to read into.
+ * @param offset The offset to start reading at.
+ * @param len The number of bytes to read.
+ * @return The number of bytes read.
+ * @throws java.io.IOException If an I/O error occurs.
+ */
+ protected int readFully(InputStream in, byte buffer[], int offset, int len)
+ throws java.io.IOException {
+ for (int i = 0; i < len; i++) {
+ int q = in.read();
+ if (q == -1) return ((i == 0) ? -1 : i);
+ buffer[i + offset] = (byte) q;
+ }
+ return len;
+ }
+
+ /**
+ * Decode the text from the InputStream and write the decoded octets to the OutputStream. This
+ * method runs until the stream is exhausted.
+ *
+ * @param aStream The input stream.
+ * @param bStream The output stream.
+ * @throws IOException An error has occurred while decoding
+ * @throws IOException The input stream is unexpectedly out of data
+ */
+ public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
+ int i;
+ int totalBytes = 0;
+
+ PushbackInputStream ps = new PushbackInputStream(aStream);
+ decodeBufferPrefix(ps, bStream);
+ while (true) {
+ int length;
+
+ try {
+ length = decodeLinePrefix(ps, bStream);
+ for (i = 0; (i + bytesPerAtom()) < length; i += bytesPerAtom()) {
+ decodeAtom(ps, bStream, bytesPerAtom());
+ totalBytes += bytesPerAtom();
+ }
+ if ((i + bytesPerAtom()) == length) {
+ decodeAtom(ps, bStream, bytesPerAtom());
+ totalBytes += bytesPerAtom();
+ } else {
+ decodeAtom(ps, bStream, length - i);
+ totalBytes += (length - i);
+ }
+ decodeLineSuffix(ps, bStream);
+ } catch (IOException e) {
+ break;
+ }
+ }
+ decodeBufferSuffix(ps, bStream);
+ }
+
+ /**
+ * Alternate decode interface that takes a String containing the encoded buffer and returns a byte
+ * array containing the data.
+ *
+ * @param inputString The string to decode.
+ * @return The decoded data.
+ * @throws IOException An error has occurred while decoding
+ */
+ public byte decodeBuffer(String inputString)[] throws IOException {
+ byte inputBuffer[] = new byte[inputString.length()];
+ ByteArrayInputStream inStream;
+ ByteArrayOutputStream outStream;
+
+ inputString.getBytes(0, inputString.length(), inputBuffer, 0);
+ inStream = new ByteArrayInputStream(inputBuffer);
+ outStream = new ByteArrayOutputStream();
+ decodeBuffer(inStream, outStream);
+ return (outStream.toByteArray());
+ }
+
+ /**
+ * Decode the contents of the inputstream into a buffer.
+ *
+ * @param in The input stream.
+ * @return The decoded data.
+ * @throws IOException If an I/O error occurs.
+ */
+ public byte decodeBuffer(InputStream in)[] throws IOException {
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ decodeBuffer(in, outStream);
+ return (outStream.toByteArray());
+ }
+
+ /**
+ * Decode the contents of the String into a ByteBuffer.
+ *
+ * @param inputString The string to decode.
+ * @return The decoded data as a ByteBuffer.
+ * @throws IOException If an I/O error occurs.
+ */
+ public ByteBuffer decodeBufferToByteBuffer(String inputString) throws IOException {
+ return ByteBuffer.wrap(decodeBuffer(inputString));
+ }
+
+ /**
+ * Decode the contents of the inputStream into a ByteBuffer.
+ *
+ * @param in The input stream.
+ * @return The decoded data as a ByteBuffer.
+ * @throws IOException If an I/O error occurs.
+ */
+ public ByteBuffer decodeBufferToByteBuffer(InputStream in) throws IOException {
+ return ByteBuffer.wrap(decodeBuffer(in));
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterEncoder.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterEncoder.java
new file mode 100644
index 000000000..67581fc64
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/CharacterEncoder.java
@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 1995, 2005, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.sunbird.datasecurity.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.nio.ByteBuffer;
+
+/**
+ * This class defines the encoding half of character encoders. A character encoder is an algorithim
+ * for transforming 8 bit binary data into text (generally 7 bit ASCII or 8 bit ISO-Latin-1 text)
+ * for transmition over text channels such as e-mail and network news.
+ *
+ *
The character encoders have been structured around a central theme that, in general, the
+ * encoded text has the form:
+ *
+ *
+ *
+ * In the CharacterEncoder and CharacterDecoder classes, one complete chunk of data is referred to
+ * as a buffer. Encoded buffers are all text, and decoded buffers (sometimes just referred to
+ * as buffers) are binary octets.
+ *
+ *
To create a custom encoder, you must, at a minimum, overide three abstract methods in this
+ * class.
+ *
+ *
+ *
bytesPerAtom which tells the encoder how many bytes to send to encodeAtom
+ *
encodeAtom which encodes the bytes sent to it as text.
+ *
bytesPerLine which tells the encoder the maximum number of bytes per line.
+ *
+ *
+ * Several useful encoders have already been written and are referenced in the See Also list below.
+ *
+ * @author Chuck McManis
+ * @see CharacterDecoder
+ * @see BASE64Encoder
+ */
+public abstract class CharacterEncoder {
+ /** Stream that understands "printing" */
+ protected PrintStream pStream;
+
+ /**
+ * Return the number of bytes per atom of encoding
+ *
+ * @return The number of bytes per atom.
+ */
+ protected abstract int bytesPerAtom();
+
+ /**
+ * Return the number of bytes that can be encoded per line
+ *
+ * @return The maximum number of bytes per line.
+ */
+ protected abstract int bytesPerLine();
+
+ /**
+ * Encode the prefix for the entire buffer. By default is simply opens the PrintStream for use by
+ * the other functions.
+ *
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void encodeBufferPrefix(OutputStream aStream) throws IOException {
+ pStream = new PrintStream(aStream);
+ }
+
+ /**
+ * Encode the suffix for the entire buffer.
+ *
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void encodeBufferSuffix(OutputStream aStream) throws IOException {}
+
+ /**
+ * Encode the prefix that starts every output line.
+ *
+ * @param aStream The output stream.
+ * @param aLength The number of bytes to be encoded.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void encodeLinePrefix(OutputStream aStream, int aLength) throws IOException {}
+
+ /**
+ * Encode the suffix that ends every output line. By default this method just prints a
+ * into the output stream.
+ *
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected void encodeLineSuffix(OutputStream aStream) throws IOException {
+ pStream.println();
+ }
+
+ /**
+ * Encode one "atom" of information into characters.
+ *
+ * @param aStream The output stream.
+ * @param someBytes The input buffer.
+ * @param anOffset The offset to start reading at.
+ * @param aLength The number of bytes to encode.
+ * @throws IOException If an I/O error occurs.
+ */
+ protected abstract void encodeAtom(
+ OutputStream aStream, byte someBytes[], int anOffset, int aLength) throws IOException;
+
+ /**
+ * This method works around the bizarre semantics of BufferedInputStream's read method.
+ *
+ * @param in The input stream.
+ * @param buffer The buffer to read into.
+ * @return The number of bytes read.
+ * @throws java.io.IOException If an I/O error occurs.
+ */
+ protected int readFully(InputStream in, byte buffer[]) throws java.io.IOException {
+ for (int i = 0; i < buffer.length; i++) {
+ int q = in.read();
+ if (q == -1) return i;
+ buffer[i] = (byte) q;
+ }
+ return buffer.length;
+ }
+
+ /**
+ * Encode bytes from the input stream, and write them as text characters to the output stream.
+ * This method will run until it exhausts the input stream, but does not print the line suffix for
+ * a final line that is shorter than bytesPerLine().
+ *
+ * @param inStream The input stream.
+ * @param outStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encode(InputStream inStream, OutputStream outStream) throws IOException {
+ int j;
+ int numBytes;
+ byte tmpbuffer[] = new byte[bytesPerLine()];
+
+ encodeBufferPrefix(outStream);
+
+ while (true) {
+ numBytes = readFully(inStream, tmpbuffer);
+ if (numBytes == 0) {
+ break;
+ }
+ encodeLinePrefix(outStream, numBytes);
+ for (j = 0; j < numBytes; j += bytesPerAtom()) {
+
+ if ((j + bytesPerAtom()) <= numBytes) {
+ encodeAtom(outStream, tmpbuffer, j, bytesPerAtom());
+ } else {
+ encodeAtom(outStream, tmpbuffer, j, (numBytes) - j);
+ }
+ }
+ if (numBytes < bytesPerLine()) {
+ break;
+ } else {
+ encodeLineSuffix(outStream);
+ }
+ }
+ encodeBufferSuffix(outStream);
+ }
+
+ /**
+ * Encode the buffer in aBuffer and write the encoded result to the OutputStream
+ * aStream.
+ *
+ * @param aBuffer The input buffer.
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encode(byte aBuffer[], OutputStream aStream) throws IOException {
+ ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
+ encode(inStream, aStream);
+ }
+
+ /**
+ * A 'streamless' version of encode that simply takes a buffer of bytes and returns a string
+ * containing the encoded buffer.
+ *
+ * @param aBuffer The input buffer.
+ * @return The encoded string.
+ */
+ public String encode(byte aBuffer[]) {
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
+ String retVal = null;
+ try {
+ encode(inStream, outStream);
+ // explicit ascii->unicode conversion
+ retVal = outStream.toString("8859_1");
+ } catch (Exception IOException) {
+ // This should never happen.
+ throw new Error("CharacterEncoder.encode internal error");
+ }
+ return (retVal);
+ }
+
+ /**
+ * Return a byte array from the remaining bytes in this ByteBuffer.
+ *
+ *
The ByteBuffer's position will be advanced to ByteBuffer's limit.
+ *
+ *
To avoid an extra copy, the implementation will attempt to return the byte array backing the
+ * ByteBuffer. If this is not possible, a new byte array will be created.
+ *
+ * @param bb The input ByteBuffer.
+ * @return The byte array.
+ */
+ private byte[] getBytes(ByteBuffer bb) {
+ /*
+ * This should never return a BufferOverflowException, as we're
+ * careful to allocate just the right amount.
+ */
+ byte[] buf = null;
+
+ /*
+ * If it has a usable backing byte buffer, use it. Use only
+ * if the array exactly represents the current ByteBuffer.
+ */
+ if (bb.hasArray()) {
+ byte[] tmp = bb.array();
+ if ((tmp.length == bb.capacity()) && (tmp.length == bb.remaining())) {
+ buf = tmp;
+ bb.position(bb.limit());
+ }
+ }
+
+ if (buf == null) {
+ /*
+ * This class doesn't have a concept of encode(buf, len, off),
+ * so if we have a partial buffer, we must reallocate
+ * space.
+ */
+ buf = new byte[bb.remaining()];
+
+ /*
+ * position() automatically updated
+ */
+ bb.get(buf);
+ }
+
+ return buf;
+ }
+
+ /**
+ * Encode the aBuffer ByteBuffer and write the encoded result to the OutputStream
+ * aStream.
+ *
+ *
The ByteBuffer's position will be advanced to ByteBuffer's limit.
+ *
+ * @param aBuffer The input ByteBuffer.
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encode(ByteBuffer aBuffer, OutputStream aStream) throws IOException {
+ byte[] buf = getBytes(aBuffer);
+ encode(buf, aStream);
+ }
+
+ /**
+ * A 'streamless' version of encode that simply takes a ByteBuffer and returns a string containing
+ * the encoded buffer.
+ *
+ *
The ByteBuffer's position will be advanced to ByteBuffer's limit.
+ *
+ * @param aBuffer The input ByteBuffer.
+ * @return The encoded string.
+ */
+ public String encode(ByteBuffer aBuffer) {
+ byte[] buf = getBytes(aBuffer);
+ return encode(buf);
+ }
+
+ /**
+ * Encode bytes from the input stream, and write them as text characters to the output stream.
+ * This method will run until it exhausts the input stream. It differs from encode in that it will
+ * add the line at the end of a final line that is shorter than bytesPerLine().
+ *
+ * @param inStream The input stream.
+ * @param outStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encodeBuffer(InputStream inStream, OutputStream outStream) throws IOException {
+ int j;
+ int numBytes;
+ byte tmpbuffer[] = new byte[bytesPerLine()];
+
+ encodeBufferPrefix(outStream);
+
+ while (true) {
+ numBytes = readFully(inStream, tmpbuffer);
+ if (numBytes == 0) {
+ break;
+ }
+ encodeLinePrefix(outStream, numBytes);
+ for (j = 0; j < numBytes; j += bytesPerAtom()) {
+ if ((j + bytesPerAtom()) <= numBytes) {
+ encodeAtom(outStream, tmpbuffer, j, bytesPerAtom());
+ } else {
+ encodeAtom(outStream, tmpbuffer, j, (numBytes) - j);
+ }
+ }
+ encodeLineSuffix(outStream);
+ if (numBytes < bytesPerLine()) {
+ break;
+ }
+ }
+ encodeBufferSuffix(outStream);
+ }
+
+ /**
+ * Encode the buffer in aBuffer and write the encoded result to the OutputStream
+ * aStream.
+ *
+ * @param aBuffer The input buffer.
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encodeBuffer(byte aBuffer[], OutputStream aStream) throws IOException {
+ ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
+ encodeBuffer(inStream, aStream);
+ }
+
+ /**
+ * A 'streamless' version of encode that simply takes a buffer of bytes and returns a string
+ * containing the encoded buffer.
+ *
+ * @param aBuffer The input buffer.
+ * @return The encoded string.
+ */
+ public String encodeBuffer(byte aBuffer[]) {
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
+ try {
+ encodeBuffer(inStream, outStream);
+ } catch (Exception IOException) {
+ // This should never happen.
+ throw new Error("CharacterEncoder.encodeBuffer internal error");
+ }
+ return (outStream.toString());
+ }
+
+ /**
+ * Encode the aBuffer ByteBuffer and write the encoded result to the OutputStream
+ * aStream.
+ *
+ *
The ByteBuffer's position will be advanced to ByteBuffer's limit.
+ *
+ * @param aBuffer The input ByteBuffer.
+ * @param aStream The output stream.
+ * @throws IOException If an I/O error occurs.
+ */
+ public void encodeBuffer(ByteBuffer aBuffer, OutputStream aStream) throws IOException {
+ byte[] buf = getBytes(aBuffer);
+ encodeBuffer(buf, aStream);
+ }
+
+ /**
+ * A 'streamless' version of encode that simply takes a ByteBuffer and returns a string containing
+ * the encoded buffer.
+ *
+ *
The ByteBuffer's position will be advanced to ByteBuffer's limit.
+ *
+ * @param aBuffer The input ByteBuffer.
+ * @return The encoded string.
+ */
+ public String encodeBuffer(ByteBuffer aBuffer) {
+ byte[] buf = getBytes(aBuffer);
+ return encodeBuffer(buf);
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/datasecurity/impl/DefaultDataMaskServiceImpl.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDataMaskServiceImpl.java
similarity index 56%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/datasecurity/impl/DefaultDataMaskServiceImpl.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDataMaskServiceImpl.java
index 03782cb97..9cf94825a 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/datasecurity/impl/DefaultDataMaskServiceImpl.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDataMaskServiceImpl.java
@@ -1,14 +1,23 @@
-/** */
-package org.sunbird.common.models.util.datasecurity.impl;
+package org.sunbird.datasecurity.impl;
import org.apache.commons.lang3.StringUtils;
-import org.sunbird.common.models.util.JsonKey;
-import org.sunbird.common.models.util.ProjectUtil;
-import org.sunbird.common.models.util.datasecurity.DataMaskingService;
+import org.sunbird.datasecurity.DataMaskingService;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.common.ProjectUtil;
-/** @author Manzarul */
+/**
+ * Default implementation of the {@link DataMaskingService} interface.
+ * Provides functionality to mask phone numbers and email addresses.
+ */
public class DefaultDataMaskServiceImpl implements DataMaskingService {
+ /**
+ * Masks a phone number by keeping the last 4 digits visible.
+ * Masking character is defined in JsonKey.REPLACE_WITH_ASTERISK.
+ *
+ * @param phone The phone number to mask.
+ * @return The masked phone number, or the original if it is blank or shorter than 10 characters.
+ */
@Override
public String maskPhone(String phone) {
if (StringUtils.isBlank(phone) || phone.length() < 10) {
@@ -28,6 +37,14 @@ public String maskPhone(String phone) {
return builder.toString();
}
+ /**
+ * Masks an email address.
+ * Keeps the first 2 characters and the domain part (after the last @) visible.
+ * Masks characters in between.
+ *
+ * @param email The email address to mask.
+ * @return The masked email address, or the original if it is blank or invalid.
+ */
@Override
public String maskEmail(String email) {
if ((StringUtils.isBlank(email)) || (!ProjectUtil.isEmailvalid(email))) {
@@ -46,3 +63,5 @@ public String maskEmail(String email) {
return builder.toString();
}
}
+
+
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDecryptionServiceImpl.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDecryptionServiceImpl.java
new file mode 100644
index 000000000..ae2e2d2f2
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultDecryptionServiceImpl.java
@@ -0,0 +1,217 @@
+package org.sunbird.datasecurity.impl;
+
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.crypto.Cipher;
+import javax.crypto.spec.SecretKeySpec;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.datasecurity.DecryptionService;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.request.RequestContext;
+import org.sunbird.common.ProjectUtil;
+
+/**
+ * Default implementation of the {@link DecryptionService} interface.
+ * Uses AES encryption algorithm to decrypt data.
+ */
+public class DefaultDecryptionServiceImpl implements DecryptionService {
+ private static final LoggerUtil logger = new LoggerUtil(DefaultDecryptionServiceImpl.class);
+
+ private static String sunbird_encryption = "";
+
+ private String sunbirdEncryption = "";
+
+ private static Cipher c;
+
+ static {
+ try {
+ sunbird_encryption = DefaultEncryptionServiceImpl.getSalt();
+ Key key = generateKey();
+ c = Cipher.getInstance(ALGORITHM);
+ c.init(Cipher.DECRYPT_MODE, key);
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ }
+ }
+
+ public DefaultDecryptionServiceImpl() {
+ sunbirdEncryption = System.getenv(JsonKey.SUNBIRD_ENCRYPTION);
+ if (StringUtils.isBlank(sunbirdEncryption)) {
+ sunbirdEncryption = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_ENCRYPTION);
+ }
+ }
+
+ /**
+ * Decrypts values in a map if encryption is enabled.
+ * Modifies the map in-place.
+ *
+ * @param data The map containing data to decrypt.
+ * @param context The request context.
+ * @return The data map with decrypted values.
+ */
+ @Override
+ public Map decryptData(Map data, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (data == null) {
+ return data;
+ }
+ Iterator> itr = data.entrySet().iterator();
+ while (itr.hasNext()) {
+ Entry entry = itr.next();
+ if (!(entry.getValue() instanceof Map || entry.getValue() instanceof List)
+ && null != entry.getValue()) {
+ data.put(entry.getKey(), decrypt(entry.getValue() + "", false, context));
+ }
+ }
+ }
+ return data;
+ }
+
+ /**
+ * Decrypts values in a list of maps.
+ *
+ * @param data The list of maps to decrypt.
+ * @param context The request context.
+ * @return The list of maps with decrypted values.
+ */
+ @Override
+ public List> decryptData(
+ List> data, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (data == null || data.isEmpty()) {
+ return data;
+ }
+
+ for (Map map : data) {
+ decryptData(map, context);
+ }
+ }
+ return data;
+ }
+
+ /**
+ * Decrypts a single string value.
+ *
+ * @param data The string to decrypt.
+ * @param context The request context.
+ * @return The decrypted string, or the original string if encryption is disabled.
+ */
+ @Override
+ public String decryptData(String data, RequestContext context) {
+ return decryptData(data, false, context);
+ }
+
+ /**
+ * Decrypts a single string value, optionally throwing an exception on failure.
+ *
+ * @param data The string to decrypt.
+ * @param throwExceptionOnFailure Whether to throw an exception if decryption fails.
+ * @param context The request context.
+ * @return The decrypted string.
+ */
+ @Override
+ public String decryptData(String data, boolean throwExceptionOnFailure, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (StringUtils.isBlank(data)) {
+ return data;
+ } else {
+ return decrypt(data, throwExceptionOnFailure, context);
+ }
+ } else {
+ return data;
+ }
+ }
+
+ /**
+ * Internal method to perform the decryption logic.
+ *
+ * @param value The value to decrypt.
+ * @param throwExceptionOnFailure Whether to throw an exception on error.
+ * @param context The request context.
+ * @return The decrypted value.
+ */
+ public static String decrypt(
+ String value, boolean throwExceptionOnFailure, RequestContext context) {
+ try {
+ String dValue = null;
+ String valueToDecrypt = value.trim();
+ for (int i = 0; i < ITERATIONS; i++) {
+ byte[] decordedValue = new BASE64Decoder().decodeBuffer(valueToDecrypt);
+ byte[] decValue = c.doFinal(decordedValue);
+ dValue =
+ new String(decValue, StandardCharsets.UTF_8).substring(sunbird_encryption.length());
+ valueToDecrypt = dValue;
+ }
+ return dValue;
+ } catch (Exception ex) {
+ // This could happen with masked email and phone number. Not others.
+ logger.error(context, "DefaultDecryptionServiceImpl:decrypt: ignorable errorMsg = ", ex);
+ if (throwExceptionOnFailure) {
+ logger.info(
+ context, "Throwing exception error upon explicit ask by callers for value " + value);
+ ProjectCommonException.throwServerErrorException(ResponseCode.SERVER_ERROR);
+ }
+ }
+ return value;
+ }
+
+ private static Key generateKey() {
+ return new SecretKeySpec(keyValue, ALGORITHM);
+ }
+
+ /**
+ * Decrypts values in a map without a request context.
+ * Delegates to {@link #decryptData(Map, RequestContext)} with null context.
+ *
+ * @param data The map containing data to decrypt.
+ * @return The data map with decrypted values.
+ */
+ @Override
+ public Map decryptData(Map data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts values in a list of maps without a request context.
+ * Delegates to {@link #decryptData(List, RequestContext)} with null context.
+ *
+ * @param data The list of maps to decrypt.
+ * @return The list of maps with decrypted values.
+ */
+ @Override
+ public List> decryptData(List> data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts a single string value without a request context.
+ * Delegates to {@link #decryptData(String, RequestContext)} with null context.
+ *
+ * @param data The string to decrypt.
+ * @return The decrypted string.
+ */
+ @Override
+ public String decryptData(String data) {
+ return decryptData(data, null);
+ }
+
+ /**
+ * Decrypts a single string value without a request context, optionally throwing an exception on failure.
+ * Delegates to {@link #decryptData(String, boolean, RequestContext)} with null context.
+ *
+ * @param data The string to decrypt.
+ * @param throwExceptionOnFailure Whether to throw an exception if decryption fails.
+ * @return The decrypted string.
+ */
+ @Override
+ public String decryptData(String data, boolean throwExceptionOnFailure) {
+ return decryptData(data, throwExceptionOnFailure, null);
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultEncryptionServiceImpl.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultEncryptionServiceImpl.java
new file mode 100644
index 000000000..568272eb5
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/DefaultEncryptionServiceImpl.java
@@ -0,0 +1,215 @@
+package org.sunbird.datasecurity.impl;
+
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.crypto.Cipher;
+import javax.crypto.spec.SecretKeySpec;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.datasecurity.EncryptionService;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.request.RequestContext;
+import org.sunbird.common.ProjectUtil;
+
+/**
+ * Default implementation of the {@link EncryptionService} interface.
+ * Uses AES encryption algorithm to encrypt data.
+ */
+public class DefaultEncryptionServiceImpl implements EncryptionService {
+ private static final LoggerUtil logger = new LoggerUtil(DefaultEncryptionServiceImpl.class);
+
+ private static String encryption_key = "";
+
+ private String sunbirdEncryption = "";
+
+ private static Cipher c;
+
+ static {
+ try {
+ encryption_key = getSalt();
+ Key key = generateKey();
+ c = Cipher.getInstance(ALGORITHM);
+ c.init(Cipher.ENCRYPT_MODE, key);
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ }
+ }
+
+ public DefaultEncryptionServiceImpl() {
+ sunbirdEncryption = System.getenv(JsonKey.SUNBIRD_ENCRYPTION);
+ if (StringUtils.isBlank(sunbirdEncryption)) {
+ sunbirdEncryption = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_ENCRYPTION);
+ }
+ }
+
+ /**
+ * Encrypts the values in a map.
+ *
+ * @param data The map containing data to encrypt.
+ * @param context The request context.
+ * @return The map with encrypted values.
+ */
+ @Override
+ public Map encryptData(Map data, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (data == null) {
+ return data;
+ }
+ Iterator> itr = data.entrySet().iterator();
+ while (itr.hasNext()) {
+ Entry entry = itr.next();
+ if (!(entry.getValue() instanceof Map || entry.getValue() instanceof List)
+ && null != entry.getValue()) {
+ data.put(entry.getKey(), encrypt(entry.getValue() + "", context));
+ }
+ }
+ }
+ return data;
+ }
+
+ /**
+ * Encrypts the values in a list of maps.
+ *
+ * @param data The list of maps to encrypt.
+ * @param context The request context.
+ * @return The list of maps with encrypted values.
+ */
+ @Override
+ public List> encryptData(
+ List> data, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (data == null || data.isEmpty()) {
+ return data;
+ }
+ for (Map map : data) {
+ encryptData(map, context);
+ }
+ }
+ return data;
+ }
+
+ /**
+ * Encrypts a single string value.
+ *
+ * @param data The string to encrypt.
+ * @param context The request context.
+ * @return The encrypted string.
+ */
+ @Override
+ public String encryptData(String data, RequestContext context) {
+ if (JsonKey.ON.equalsIgnoreCase(sunbirdEncryption)) {
+ if (StringUtils.isNotBlank(data)) {
+ return encrypt(data, context);
+ } else {
+ return data;
+ }
+ } else {
+ return data;
+ }
+ }
+
+ /**
+ * Encrypts the given value using the configured algorithm/key.
+ *
+ * @param value String password or data to encrypt.
+ * @param context The request context.
+ * @return encrypted string.
+ */
+ @SuppressWarnings("restriction")
+ public static String encrypt(String value, RequestContext context) {
+ String valueToEnc = null;
+ String eValue = value;
+ for (int i = 0; i < ITERATIONS; i++) {
+ valueToEnc = encryption_key + eValue;
+ byte[] encValue = new byte[0];
+ try {
+ encValue = c.doFinal(valueToEnc.getBytes(StandardCharsets.UTF_8));
+ } catch (Exception e) {
+ logger.error(
+ context, "Exception while encrypting user data, with message : " + e.getMessage(), e);
+ throw new ProjectCommonException(
+ ResponseCode.serverError,
+ ResponseCode.serverError.getErrorMessage(),
+ ResponseCode.SERVER_ERROR.getResponseCode());
+ }
+ eValue = new BASE64Encoder().encode(encValue);
+ }
+ return eValue;
+ }
+
+ private static Key generateKey() {
+ return new SecretKeySpec(keyValue, ALGORITHM);
+ }
+
+ /**
+ * Retrieves the encryption salt (key) from environment or config.
+ * @return The encryption key.
+ */
+ public static String getSalt() {
+ if (!StringUtils.isBlank(encryption_key)) {
+ return encryption_key;
+ } else {
+ encryption_key = System.getenv(JsonKey.ENCRYPTION_KEY);
+ if (StringUtils.isBlank(encryption_key)) {
+ logger.info("Salt value is not provided by Env");
+ encryption_key = ProjectUtil.getConfigValue(JsonKey.ENCRYPTION_KEY);
+ }
+ }
+ if (StringUtils.isBlank(encryption_key)) {
+ logger.info("throwing exception for invalid salt");
+ throw new ProjectCommonException(
+ ResponseCode.invalidParameterValue,
+ String.format(
+ ResponseCode.invalidParameterValue.getErrorMessage(), JsonKey.ENCRYPTION_KEY),
+ ResponseCode.SERVER_ERROR.getResponseCode());
+ }
+ return encryption_key;
+ }
+
+ /**
+ * Encrypts the values in a map without a request context.
+ * Delegates to {@link #encryptData(Map, RequestContext)} with null context.
+ *
+ * @param data The map containing data to encrypt.
+ * @return The map with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ @Override
+ public Map encryptData(Map data) throws Exception {
+ return encryptData(data, null);
+ }
+
+ /**
+ * Encrypts the values in a list of maps without a request context.
+ * Delegates to {@link #encryptData(List, RequestContext)} with null context.
+ *
+ * @param data The list of maps to encrypt.
+ * @return The list of maps with encrypted values.
+ * @throws Exception If an error occurs during encryption.
+ */
+ @Override
+ public List> encryptData(List> data) throws Exception {
+ return encryptData(data, null);
+ }
+
+ /**
+ * Encrypts a single string value without a request context.
+ * Delegates to {@link #encryptData(String, RequestContext)} with null context.
+ *
+ * @param data The string to encrypt.
+ * @return The encrypted string.
+ * @throws Exception If an error occurs during encryption.
+ */
+ @Override
+ public String encryptData(String data) throws Exception {
+ return encryptData(data, null);
+ }
+}
+
+
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/LogMaskServiceImpl.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/LogMaskServiceImpl.java
new file mode 100644
index 000000000..db888a2d5
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/LogMaskServiceImpl.java
@@ -0,0 +1,40 @@
+package org.sunbird.datasecurity.impl;
+
+import org.sunbird.datasecurity.DataMaskingService;
+
+/**
+ * Implementation of DataMaskingService for logging purposes.
+ * Provides masking logic suitable for log outputs.
+ */
+public class LogMaskServiceImpl implements DataMaskingService {
+
+ /**
+ * Masks an email address for logging.
+ * If the local part (before @) is longer than 4 characters, keeps the first 4 visible.
+ * Otherwise, keeps the first 2 visible.
+ * The domain part is kept visible.
+ *
+ * @param email The email address to mask.
+ * @return The masked email address.
+ */
+ @Override
+ public String maskEmail(String email) {
+ if (email.indexOf("@") > 4) {
+ return email.replaceAll("(^[^@]{4}|(?!^)\\G)[^@]", "$1*");
+ } else {
+ return email.replaceAll("(^[^@]{2}|(?!^)\\G)[^@]", "$1*");
+ }
+ }
+
+ /**
+ * Masks a phone number for logging.
+ * Masks all but the last digit (assuming 10-digit standard for the regex logic).
+ *
+ * @param phone The phone number to mask.
+ * @return The masked phone number.
+ */
+ @Override
+ public String maskPhone(String phone) {
+ return phone.replaceAll("(^[^*]{9}|(?!^)\\G)[^*]", "$1*");
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/ServiceFactory.java b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/ServiceFactory.java
new file mode 100644
index 000000000..e9d9939b1
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/datasecurity/impl/ServiceFactory.java
@@ -0,0 +1,114 @@
+package org.sunbird.datasecurity.impl;
+
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.datasecurity.DataMaskingService;
+import org.sunbird.datasecurity.DecryptionService;
+import org.sunbird.datasecurity.EncryptionService;
+
+/**
+ * Factory class to provide instances of data security services.
+ * Supports EncryptionService, DecryptionService, and DataMaskingService.
+ * Provides both parameterized (for backward compatibility) and non-parameterized factory methods.
+ */
+public class ServiceFactory {
+
+ private static EncryptionService encryptionService;
+ private static DecryptionService decryptionService;
+ private static DataMaskingService maskingService;
+
+ static {
+ encryptionService = new DefaultEncryptionServiceImpl();
+ decryptionService = new DefaultDecryptionServiceImpl();
+ maskingService = new DefaultDataMaskServiceImpl();
+ }
+
+ /**
+ * Provides the default instance of EncryptionService.
+ *
+ * @return The default EncryptionService instance.
+ */
+ public static EncryptionService getEncryptionServiceInstance() {
+ return encryptionService;
+ }
+
+ /**
+ * Provides an instance of EncryptionService.
+ * Currently, returns the default instance regardless of the input value,
+ * but supports the parameter for backward compatibility.
+ *
+ * @param val The type of service implementation required (e.g., "defaultEncryption").
+ * Pass null or empty for the default implementation.
+ * @return An instance of EncryptionService.
+ */
+ public static EncryptionService getEncryptionServiceInstance(String val) {
+ if (StringUtils.isBlank(val)) {
+ return encryptionService;
+ }
+ switch (val) {
+ case "defaultEncryption":
+ return encryptionService;
+ default:
+ return encryptionService;
+ }
+ }
+
+ /**
+ * Provides the default instance of DecryptionService.
+ *
+ * @return The default DecryptionService instance.
+ */
+ public static DecryptionService getDecryptionServiceInstance() {
+ return decryptionService;
+ }
+
+ /**
+ * Provides an instance of DecryptionService.
+ * Currently, returns the default instance regardless of the input value,
+ * but supports the parameter for backward compatibility.
+ *
+ * @param val The type of service implementation required (e.g., "defaultDecryption").
+ * Pass null or empty for the default implementation.
+ * @return An instance of DecryptionService.
+ */
+ public static DecryptionService getDecryptionServiceInstance(String val) {
+ if (StringUtils.isBlank(val)) {
+ return decryptionService;
+ }
+ switch (val) {
+ case "defaultDecryption":
+ return decryptionService;
+ default:
+ return decryptionService;
+ }
+ }
+
+ /**
+ * Provides the default instance of DataMaskingService.
+ *
+ * @return The default DataMaskingService instance.
+ */
+ public static DataMaskingService getMaskingServiceInstance() {
+ return maskingService;
+ }
+
+ /**
+ * Provides an instance of DataMaskingService.
+ * Currently, returns the default instance regardless of the input value,
+ * but supports the parameter for backward compatibility.
+ *
+ * @param val The type of service implementation required (e.g., "defaultMasking").
+ * Pass null or empty for the default implementation.
+ * @return An instance of DataMaskingService.
+ */
+ public static DataMaskingService getMaskingServiceInstance(String val) {
+ if (StringUtils.isBlank(val)) {
+ return maskingService;
+ }
+ switch (val) {
+ case "defaultMasking":
+ return maskingService;
+ default:
+ return maskingService;
+ }
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/exception/ProjectCommonException.java b/core/sunbird-platform-common/src/main/java/org/sunbird/exception/ProjectCommonException.java
new file mode 100644
index 000000000..ecfbf7e57
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/exception/ProjectCommonException.java
@@ -0,0 +1,283 @@
+package org.sunbird.exception;
+
+import java.text.MessageFormat;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.keys.JsonKey;
+
+/**
+ * A comprehensive exception class used across the backend to handle error scenarios.
+ * This class encapsulates error codes, messages, and HTTP status codes, supporting both
+ * unified error handling and backward compatibility for various service modules.
+ */
+public class ProjectCommonException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /** The application-specific error code (e.g., "ERR_USER_NOT_FOUND"). */
+ private String errorCode;
+
+ /** The human-readable error message. */
+ private String errorMessage;
+
+ /** The HTTP status code associated with this error (e.g., 400, 404, 500). */
+ private int errorResponseCode;
+
+ /** The rich enum representation of the error, if available. */
+ private ResponseCode responseCode;
+
+ /**
+ * Constructs a new ProjectCommonException using a ResponseCode enum.
+ *
+ * @param code The ResponseCode enum representing the error type.
+ * @param message A custom error message description.
+ * @param responseCode The HTTP status code to return to the client.
+ */
+ public ProjectCommonException(ResponseCode code, String message, int responseCode) {
+ super(message);
+ this.responseCode = code;
+ this.errorCode = code.getErrorCode();
+ this.errorMessage = message;
+ this.errorResponseCode = responseCode;
+ }
+
+ /**
+ * Constructs a new ProjectCommonException with a string error code.
+ * This constructor is primarily used for scenarios where a ResponseCode enum is not strictly required.
+ *
+ * @param errorCode The string representation of the error code.
+ * @param message The error message description.
+ * @param responseCode The HTTP status code to return to the client.
+ */
+ public ProjectCommonException(String errorCode, String message, int responseCode) {
+ super(message);
+ this.errorCode = errorCode;
+ this.errorMessage = message;
+ this.errorResponseCode = responseCode;
+ this.responseCode = null;
+ }
+
+ /**
+ * Constructs a new ProjectCommonException wrapping another exception, typically for actor operations.
+ * Adds service-specific prefixes to the error code.
+ *
+ * @param pce The original ProjectCommonException to wrap.
+ * @param actorOperation The actor operation context to append to the error code prefix.
+ */
+ public ProjectCommonException(ProjectCommonException pce, String actorOperation) {
+ super(pce.getMessage());
+ this.setStackTrace(pce.getStackTrace());
+ this.errorCode =
+ new StringBuilder(JsonKey.USER_ORG_SERVICE_PREFIX)
+ .append(actorOperation)
+ .append(pce.getErrorCode())
+ .toString();
+ this.errorResponseCode = pce.getErrorResponseCode();
+ this.errorMessage = pce.getMessage();
+ this.responseCode = pce.getResponseCodeEnum();
+ }
+
+ /**
+ * Constructs a new ProjectCommonException with message formatting support.
+ * Replaces placeholders in the message with provided values.
+ *
+ * @param code The ResponseCode enum.
+ * @param messageWithPlaceholder The error message pattern containing placeholders.
+ * @param responseCode The HTTP status code.
+ * @param placeholderValue The values to substitute into the message placeholders.
+ */
+ public ProjectCommonException(
+ ResponseCode code,
+ String messageWithPlaceholder,
+ int responseCode,
+ String... placeholderValue) {
+ super(MessageFormat.format(messageWithPlaceholder, placeholderValue));
+ this.errorCode = code.getErrorCode();
+ this.errorMessage = MessageFormat.format(messageWithPlaceholder, placeholderValue);
+ this.errorResponseCode = responseCode;
+ this.responseCode = code;
+ }
+
+ // --- Getters and Setters ---
+
+ public String getErrorCode() {
+ return errorCode;
+ }
+
+ public void setErrorCode(String code) {
+ this.errorCode = code;
+ }
+
+ @Override
+ public String getMessage() {
+ return errorMessage;
+ }
+
+ public void setMessage(String message) {
+ this.errorMessage = message;
+ }
+
+ /**
+ * Gets the HTTP response status code.
+ *
+ * @return The HTTP status code as an integer.
+ */
+ public int getErrorResponseCode() {
+ return errorResponseCode;
+ }
+
+ public void setErrorResponseCode(int responseCode) {
+ this.errorResponseCode = responseCode;
+ }
+
+ /**
+ * Gets the ResponseCode enum.
+ *
+ * @return The ResponseCode enum, or null if initialized with the raw string constructor.
+ */
+ public ResponseCode getResponseCodeEnum() {
+ return responseCode;
+ }
+
+ public void setResponseCodeEnum(ResponseCode responseCode) {
+ this.responseCode = responseCode;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public void setErrorMessage(String errorMessage) {
+ this.errorMessage = errorMessage;
+ }
+
+ // --- Backward Compatibility Aliases ---
+
+ /**
+ * Gets the error code. Kept for backward compatibility.
+ *
+ * @return The error code string.
+ * @see #getErrorCode()
+ */
+ public String getCode() {
+ return getErrorCode();
+ }
+
+ /**
+ * Sets the error code. Kept for backward compatibility.
+ *
+ * @param code The error code string.
+ * @see #setErrorCode(String)
+ */
+ public void setCode(String code) {
+ setErrorCode(code);
+ }
+
+ /**
+ * Gets the HTTP response code. Kept for backward compatibility.
+ *
+ * @return The integer HTTP response code.
+ * @see #getErrorResponseCode()
+ */
+ public int getResponseCode() {
+ return errorResponseCode;
+ }
+
+ /**
+ * Sets the HTTP response code. Kept for backward compatibility.
+ *
+ * @param responseCode The integer HTTP response code.
+ * @see #setErrorResponseCode(int)
+ */
+ public void setResponseCode(int responseCode) {
+ this.errorResponseCode = responseCode;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder();
+ builder.append(errorCode).append(": ");
+ builder.append(errorMessage);
+ return builder.toString();
+ }
+
+ // --- Static Helper Methods ---
+
+ /**
+ * Throws a generic client error exception (4xx).
+ *
+ * @param responseCode The ResponseCode enum details.
+ * @param exceptionMessage A custom message to include.
+ */
+ public static void throwClientErrorException(ResponseCode responseCode, String exceptionMessage) {
+ throw new ProjectCommonException(
+ responseCode,
+ StringUtils.isBlank(exceptionMessage) ? responseCode.getErrorMessage() : exceptionMessage,
+ ResponseCode.CLIENT_ERROR.getResponseCode());
+ }
+
+ /**
+ * Throws a generic Resource Not Found exception (404).
+ */
+ public static void throwResourceNotFoundException() {
+ throw new ProjectCommonException(
+ ResponseCode.resourceNotFound,
+ MessageFormat.format(ResponseCode.resourceNotFound.getErrorMessage(), ""),
+ ResponseCode.RESOURCE_NOT_FOUND.getResponseCode());
+ }
+
+ /**
+ * Throws a Resource Not Found exception (404) with a custom message.
+ *
+ * @param responseCode The ResponseCode enum details.
+ * @param exceptionMessage A custom message to include.
+ */
+ public static void throwResourceNotFoundException(
+ ResponseCode responseCode, String exceptionMessage) {
+ throw new ProjectCommonException(
+ responseCode,
+ StringUtils.isBlank(exceptionMessage) ? responseCode.getErrorMessage() : exceptionMessage,
+ ResponseCode.RESOURCE_NOT_FOUND.getResponseCode());
+ }
+
+ /**
+ * Throws a generic Server Error exception (5xx).
+ *
+ * @param responseCode The ResponseCode enum details.
+ * @param exceptionMessage A custom message to include.
+ */
+ public static void throwServerErrorException(ResponseCode responseCode, String exceptionMessage) {
+ throw new ProjectCommonException(
+ responseCode,
+ StringUtils.isBlank(exceptionMessage) ? responseCode.getErrorMessage() : exceptionMessage,
+ ResponseCode.SERVER_ERROR.getResponseCode());
+ }
+
+ /**
+ * Throws a generic Server Error exception (5xx) using the default enum message.
+ *
+ * @param responseCode The ResponseCode enum details.
+ */
+ public static void throwServerErrorException(ResponseCode responseCode) {
+ throwServerErrorException(responseCode, responseCode.getErrorMessage());
+ }
+
+ /**
+ * Throws a generic Client Error exception (4xx) using the default enum message.
+ *
+ * @param responseCode The ResponseCode enum details.
+ */
+ public static void throwClientErrorException(ResponseCode responseCode) {
+ throwClientErrorException(responseCode, responseCode.getErrorMessage());
+ }
+
+ /**
+ * Throws the standard Unauthorized exception (401).
+ */
+ public static void throwUnauthorizedErrorException() {
+ throw new ProjectCommonException(
+ ResponseCode.unAuthorized,
+ ResponseCode.unAuthorized.getErrorMessage(),
+ ResponseCode.UNAUTHORIZED.getResponseCode());
+ }
+}
\ No newline at end of file
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpClientUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpClientUtil.java
new file mode 100644
index 000000000..d0823e6fb
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpClientUtil.java
@@ -0,0 +1,380 @@
+package org.sunbird.http;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.apache.commons.collections.MapUtils;
+import org.apache.http.Consts;
+import org.apache.http.HeaderElement;
+import org.apache.http.HeaderElementIterator;
+import org.apache.http.HttpEntity;
+import org.apache.http.NameValuePair;
+import org.apache.http.StatusLine;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPatch;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.message.BasicHeaderElementIterator;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.protocol.HTTP;
+import org.apache.http.util.EntityUtils;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.request.RequestContext;
+
+/**
+ * HTTP client utility for making REST API calls.
+ *
+ *
This class provides a thread-safe singleton HTTP client with connection pooling
+ * and keep-alive strategy. It supports GET, POST, PATCH, and DELETE operations
+ * with custom headers and supports both JSON and form-encoded payloads.
+ *
+ *
Features:
+ *
+ *
Connection pooling with configurable max connections (200 total, 150 per route)
+ *
Keep-alive strategy with 180-second timeout
+ *
Automatic idle connection cleanup
+ *
Comprehensive logging with request context
+ *
+ *
+ * @author Sunbird
+ * @version 1.0
+ */
+public class HttpClientUtil {
+
+ private static final LoggerUtil logger = new LoggerUtil(HttpClientUtil.class);
+ private static final int MAX_TOTAL_CONNECTIONS = 200;
+ private static final int MAX_CONNECTIONS_PER_ROUTE = 150;
+ private static final int KEEP_ALIVE_TIMEOUT_SECONDS = 180;
+ private static final int SUCCESS_STATUS_MIN = 200;
+ private static final int SUCCESS_STATUS_MAX = 300;
+
+ private static CloseableHttpClient httpclient = null;
+ private static HttpClientUtil httpClientUtil;
+
+ /**
+ * Private constructor to initialize the HTTP client with connection pooling.
+ * Configures keep-alive strategy and connection manager settings.
+ */
+ private HttpClientUtil() {
+ ConnectionKeepAliveStrategy keepAliveStrategy =
+ (response, context) -> {
+ HeaderElementIterator it =
+ new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
+ while (it.hasNext()) {
+ HeaderElement he = it.nextElement();
+ String param = he.getName();
+ String value = he.getValue();
+ if (value != null && param.equalsIgnoreCase("timeout")) {
+ return Long.parseLong(value) * 1000;
+ }
+ }
+ return KEEP_ALIVE_TIMEOUT_SECONDS * 1000;
+ };
+
+ PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
+ connectionManager.setMaxTotal(MAX_TOTAL_CONNECTIONS);
+ connectionManager.setDefaultMaxPerRoute(MAX_CONNECTIONS_PER_ROUTE);
+ connectionManager.closeIdleConnections(KEEP_ALIVE_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+
+ httpclient =
+ HttpClients.custom()
+ .setConnectionManager(connectionManager)
+ .useSystemProperties()
+ .setKeepAliveStrategy(keepAliveStrategy)
+ .build();
+
+ logger.info(null, "HttpClientUtil initialized with max connections: " + MAX_TOTAL_CONNECTIONS);
+ }
+
+ /**
+ * Gets the singleton instance of HttpClientUtil.
+ * Thread-safe double-checked locking pattern.
+ *
+ * @return The singleton HttpClientUtil instance
+ */
+ public static HttpClientUtil getInstance() {
+ if (httpClientUtil == null) {
+ synchronized (HttpClientUtil.class) {
+ if (httpClientUtil == null) {
+ httpClientUtil = new HttpClientUtil();
+ }
+ }
+ }
+ return httpClientUtil;
+ }
+
+ /**
+ * Performs an HTTP GET request.
+ *
+ * @param requestURL The target URL for the GET request
+ * @param headers Optional HTTP headers to include in the request
+ * @param context Request context for logging and tracking
+ * @return Response body as a string, or empty string if request fails
+ */
+ public static String get(String requestURL, Map headers, RequestContext context) {
+ CloseableHttpResponse response = null;
+ try {
+ logger.debug(context, "HttpClientUtil:get: Making GET request to URL: " + requestURL);
+ HttpGet httpGet = new HttpGet(requestURL);
+
+ if (MapUtils.isNotEmpty(headers)) {
+ for (Map.Entry entry : headers.entrySet()) {
+ httpGet.addHeader(entry.getKey(), entry.getValue());
+ }
+ }
+
+ response = httpclient.execute(httpGet);
+ return getResponse(response, context, "GET");
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:get: Exception occurred while calling GET method for URL: " + requestURL, ex);
+ return "";
+ } finally {
+ closeResponse(response, context, "GET");
+ }
+ }
+
+ /**
+ * Performs an HTTP POST request with JSON payload.
+ *
+ * @param requestURL The target URL for the POST request
+ * @param params The request body as a JSON string
+ * @param headers Optional HTTP headers to include in the request
+ * @param context Request context for logging and tracking
+ * @return Response body as a string, or empty string if request fails
+ */
+ public static String post(
+ String requestURL, String params, Map headers, RequestContext context) {
+ CloseableHttpResponse response = null;
+ try {
+ logger.debug(context, "HttpClientUtil:post: Making POST request to URL: " + requestURL);
+ HttpPost httpPost = new HttpPost(requestURL);
+
+ if (MapUtils.isNotEmpty(headers)) {
+ for (Map.Entry entry : headers.entrySet()) {
+ httpPost.addHeader(entry.getKey(), entry.getValue());
+ }
+ }
+
+ StringEntity entity = new StringEntity(params, ContentType.APPLICATION_JSON);
+ httpPost.setEntity(entity);
+
+ response = httpclient.execute(httpPost);
+ return getResponse(response, context, "POST");
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:post: Exception occurred while calling POST method for URL: " + requestURL, ex);
+ return "";
+ } finally {
+ closeResponse(response, context, "POST");
+ }
+ }
+
+ /**
+ * Performs an HTTP POST request with form-encoded payload.
+ *
+ * @param requestURL The target URL for the POST request
+ * @param params Form parameters as key-value pairs
+ * @param headers Optional HTTP headers to include in the request
+ * @param context Request context for logging and tracking
+ * @return Response body as a string, or empty string if request fails
+ */
+ public static String postFormData(
+ String requestURL,
+ Map params,
+ Map headers,
+ RequestContext context) {
+ CloseableHttpResponse response = null;
+ try {
+ logger.debug(context, "HttpClientUtil:postFormData: Making POST form data request to URL: " + requestURL);
+ HttpPost httpPost = new HttpPost(requestURL);
+
+ if (MapUtils.isNotEmpty(headers)) {
+ for (Map.Entry entry : headers.entrySet()) {
+ httpPost.addHeader(entry.getKey(), entry.getValue());
+ }
+ }
+
+ List form = new ArrayList<>();
+ for (Map.Entry entry : params.entrySet()) {
+ form.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
+ }
+ UrlEncodedFormEntity entity = new UrlEncodedFormEntity(form, Consts.UTF_8);
+ httpPost.setEntity(entity);
+
+ response = httpclient.execute(httpPost);
+ return getResponse(response, context, "POST_FORM");
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:postFormData: Exception occurred while calling POST form data method for URL: " + requestURL, ex);
+ return "";
+ } finally {
+ closeResponse(response, context, "POST_FORM");
+ }
+ }
+
+ /**
+ * Performs an HTTP PATCH request with JSON payload.
+ *
+ * @param requestURL The target URL for the PATCH request
+ * @param params The request body as a JSON string
+ * @param headers Optional HTTP headers to include in the request
+ * @param context Request context for logging and tracking
+ * @return Response body as a string, or empty string if request fails
+ */
+ public static String patch(
+ String requestURL, String params, Map headers, RequestContext context) {
+ CloseableHttpResponse response = null;
+ try {
+ logger.debug(context, "HttpClientUtil:patch: Making PATCH request to URL: " + requestURL);
+ HttpPatch httpPatch = new HttpPatch(requestURL);
+
+ if (MapUtils.isNotEmpty(headers)) {
+ for (Map.Entry entry : headers.entrySet()) {
+ httpPatch.addHeader(entry.getKey(), entry.getValue());
+ }
+ }
+
+ StringEntity entity = new StringEntity(params, ContentType.APPLICATION_JSON);
+ httpPatch.setEntity(entity);
+
+ response = httpclient.execute(httpPatch);
+ return getResponse(response, context, "PATCH");
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:patch: Exception occurred while calling PATCH method for URL: " + requestURL, ex);
+ return "";
+ } finally {
+ closeResponse(response, context, "PATCH");
+ }
+ }
+
+ /**
+ * Performs an HTTP DELETE request.
+ *
+ * @param requestURL The target URL for the DELETE request
+ * @param headers Optional HTTP headers to include in the request
+ * @param context Request context for logging and tracking
+ * @return Response body as a string, or empty string if request fails
+ */
+ public static String delete(
+ String requestURL, Map headers, RequestContext context) {
+ CloseableHttpResponse response = null;
+ try {
+ logger.debug(context, "HttpClientUtil:delete: Making DELETE request to URL: " + requestURL);
+ HttpDelete httpDelete = new HttpDelete(requestURL);
+
+ if (MapUtils.isNotEmpty(headers)) {
+ for (Map.Entry entry : headers.entrySet()) {
+ httpDelete.addHeader(entry.getKey(), entry.getValue());
+ }
+ }
+
+ response = httpclient.execute(httpDelete);
+ return getResponse(response, context, "DELETE");
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:delete: Exception occurred while calling DELETE method for URL: " + requestURL, ex);
+ return "";
+ } finally {
+ closeResponse(response, context, "DELETE");
+ }
+ }
+
+ /**
+ * Extracts and returns the response body from a successful HTTP response.
+ *
+ * @param response The HTTP response object
+ * @param context Request context for logging
+ * @param method The HTTP method name for logging purposes
+ * @return Response body as a string
+ * @throws IOException If reading the response fails
+ */
+ private static String getResponse(
+ CloseableHttpResponse response, RequestContext context, String method) throws IOException {
+ int status = response.getStatusLine().getStatusCode();
+
+ if (status >= SUCCESS_STATUS_MIN && status < SUCCESS_STATUS_MAX) {
+ HttpEntity httpEntity = response.getEntity();
+ StatusLine sl = response.getStatusLine();
+
+ logger.debug(
+ context,
+ "HttpClientUtil:getResponse: Response from "
+ + method
+ + " call - Status: "
+ + sl.getStatusCode()
+ + " - "
+ + sl.getReasonPhrase());
+
+ if (null != httpEntity) {
+ byte[] bytes = EntityUtils.toByteArray(httpEntity);
+ String resp = new String(bytes);
+ logger.info(context, "HttpClientUtil:getResponse: Successfully received response from " + method + " call");
+ return resp;
+ } else {
+ logger.warn(context, "HttpClientUtil:getResponse: Response entity is null for " + method + " call", null);
+ return "";
+ }
+ } else {
+ getErrorResponse(response, method, context);
+ return "";
+ }
+ }
+
+ /**
+ * Logs error response details when an HTTP request fails.
+ *
+ * @param response The HTTP response object containing the error
+ * @param method The HTTP method name for logging purposes
+ * @param context Request context for logging
+ */
+ private static void getErrorResponse(
+ CloseableHttpResponse response, String method, RequestContext context) {
+ try {
+ HttpEntity httpEntity = response.getEntity();
+ byte[] bytes = EntityUtils.toByteArray(httpEntity);
+ StatusLine sl = response.getStatusLine();
+ String resp = new String(bytes);
+
+ logger.error(
+ context,
+ "HttpClientUtil:getErrorResponse: Error response from "
+ + method
+ + " call - Response: "
+ + resp
+ + " - Status: "
+ + sl.getStatusCode()
+ + " - "
+ + sl.getReasonPhrase(),
+ null);
+ } catch (Exception ex) {
+ logger.error(context, "HttpClientUtil:getErrorResponse: Exception occurred while fetching error response for " + method + " method", ex);
+ }
+ }
+
+ /**
+ * Safely closes the HTTP response object.
+ *
+ * @param response The HTTP response to close
+ * @param context Request context for logging
+ * @param method The HTTP method name for logging purposes
+ */
+ private static void closeResponse(
+ CloseableHttpResponse response, RequestContext context, String method) {
+ if (null != response) {
+ try {
+ response.close();
+ logger.debug(context, "HttpClientUtil:closeResponse: Successfully closed " + method + " response");
+ } catch (Exception ex) {
+ logger.error(
+ context, "HttpClientUtil:closeResponse: Exception occurred while closing " + method + " response object", ex);
+ }
+ }
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/HttpUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpUtil.java
similarity index 56%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/HttpUtil.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpUtil.java
index 176ef2241..0c288d422 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/HttpUtil.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/http/HttpUtil.java
@@ -1,21 +1,20 @@
-/** */
-package org.sunbird.common.models.util;
+package org.sunbird.http;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
import org.apache.commons.collections4.MapUtils;
-import org.sunbird.common.models.response.HttpUtilResponse;
-import org.sunbird.common.responsecode.ResponseCode;
+import org.sunbird.response.HttpUtilResponse;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.response.ResponseCode;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
/**
- * This utility method will handle external http call
- *
- * @author Manzarul
+ * Utility class to handle external HTTP calls.
+ * Provides methods for GET, POST, and PATCH requests using Unirest.
*/
public class HttpUtil {
@@ -26,9 +25,9 @@ private HttpUtil() {}
* Makes an HTTP request using GET method to the specified URL.
*
* @param requestURL the URL of the remote server
- * @param headers the Map
- * @return An String object
- * @throws IOException thrown if any I/O error occurred
+ * @param headers the Map <String,String> containing request headers
+ * @return The response body as a String, or an empty string if the call fails with a non-200 status
+ * @throws UnirestException thrown if any error occurred during the request
*/
public static String sendGetRequest(String requestURL, Map headers)
throws UnirestException {
@@ -37,10 +36,10 @@ public static String sendGetRequest(String requestURL, Map heade
if(200 == httpResponse.getStatus()) {
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
- logger.info(null, "Time taken to execute the request for Url : " + requestURL + " is: " + elapsedTime);
+ logger.info(null, "HttpUtil:sendGetRequest: Execution finished for URL: " + requestURL + ", duration: " + elapsedTime + " ms");
return httpResponse.getBody();
} else {
- logger.error(null, "Error while calling request: " + requestURL + " :: response " + httpResponse.getStatus() + " :: " + httpResponse.getBody(), null);
+ logger.error(null, "HttpUtil:sendGetRequest: Failed for URL: " + requestURL + ", Status: " + httpResponse.getStatus() + ", Response: " + httpResponse.getBody(), null);
return "";
}
}
@@ -50,8 +49,9 @@ public static String sendGetRequest(String requestURL, Map heade
*
* @param requestURL the URL of the remote server
* @param params A map containing POST data in form of key-value pairs
- * @return String
- * @throws IOException thrown if any I/O error occurred
+ * @param headers the Map <String,String> containing request headers
+ * @return The response body as a String
+ * @throws Exception thrown if any error occurred during the request
*/
public static String sendPostRequest(
String requestURL, Map params, Map headers)
@@ -62,23 +62,23 @@ public static String sendPostRequest(
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info( null,
- "HttpUtil sendPostRequest method end at =="
- + stopTime
- + " for requestURL "
+ "HttpUtil:sendPostRequest: Execution finished for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return str;
}
/**
- * Makes an HTTP request using POST method to the specified URL.
+ * Makes an HTTP request using POST method to the specified URL with a String body.
*
* @param requestURL the URL of the remote server
- * @param params A map containing POST data in form of key-value pairs
- * @return An HttpURLConnection object
- * @throws IOException thrown if any I/O error occurred
+ * @param params String payload data
+ * @param headers the Map <String,String> containing request headers
+ * @return The response body as a String
+ * @throws Exception thrown if any error occurred during the request
*/
public static String sendPostRequest(
String requestURL, String params, Map headers) throws Exception {
@@ -88,23 +88,22 @@ public static String sendPostRequest(
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info( null,
- "HttpUtil sendPostRequest method end at =="
- + stopTime
- + " for requestURL "
+ "HttpUtil:sendPostRequest: Execution finished for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return str;
}
/**
- * Makes an HTTP request using POST method to the specified URL and in response it will return Map
- * of status code with post response in String format.
+ * Makes an HTTP request using POST method to the specified URL and returns a comprehensive response object.
*
* @param requestURL the URL of the remote server
- * @param params A map containing POST data in form of key-value pairs
- * @return HttpUtilResponse
+ * @param params The request body as a String
+ * @param headers the Map <String,String> containing request headers
+ * @return HttpUtilResponse containing status code and body
* @throws IOException thrown if any I/O error occurred
*/
public static HttpUtilResponse doPostRequest(
@@ -115,17 +114,16 @@ public static HttpUtilResponse doPostRequest(
HttpResponse httpResponse = Unirest.post(requestURL).headers(headers).body(params).asString();
response = new HttpUtilResponse(httpResponse.getBody(), httpResponse.getStatus());
} catch (Exception ex) {
- logger.error(null, "Exception occurred while reading body of POST call response : " , ex);
+ logger.error(null, "HttpUtil:doPostRequest: Exception occurred while reading response body for URL: " + requestURL, ex);
}
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info(null,
- "HttpUtil doPostRequest method end at =="
- + stopTime
- + " for requestURL "
+ "HttpUtil:doPostRequest: Execution finished for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return response;
}
@@ -133,19 +131,17 @@ public static HttpUtilResponse doPostRequest(
* Makes an HTTP request using PATCH method to the specified URL.
*
* @param requestURL the URL of the remote server
- * @param params A map containing POST data in form of key-value pairs
- * @return An HttpURLConnection object
- * @throws IOException thrown if any I/O error occurred
+ * @param params The request body as a String
+ * @param headers the Map <String,String> containing request headers
+ * @return ResponseCode string success or Failure string
*/
public static String sendPatchRequest(
String requestURL, String params, Map headers) {
long startTime = System.currentTimeMillis();
logger.info(null,
- "HttpUtil sendPatchRequest method started at =="
- + startTime
- + " for requestURL and params "
+ "HttpUtil:sendPatchRequest: Started for URL: "
+ requestURL
- + " param=="
+ + " with params: "
+ params);
try {
@@ -155,47 +151,55 @@ public static String sendPatchRequest(
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info(null,
- "HttpUtil sendPatchRequest method end at =="
- + stopTime
- + " for requestURL "
+ "HttpUtil:sendPatchRequest: Success for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Status: "
+ + httpResponse.getStatus()
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return ResponseCode.success.getErrorCode();
}
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info(null,
- "Patch request failure status code =="
- + httpResponse.getStatus()
- + stopTime
- + " for requestURL "
+ "HttpUtil:sendPatchRequest: Failed for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Status: "
+ + httpResponse.getStatus()
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return "Failure";
} catch (Exception e) {
- logger.error(null, "HttpUtil call fails == " + e.getMessage(), e);
+ logger.error(null, "HttpUtil:sendPatchRequest: Exception for URL: " + requestURL, e);
}
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
logger.info( null,
- "HttpUtil sendPatchRequest method end at =="
- + stopTime
- + " for requestURL "
+ "HttpUtil:sendPatchRequest: Ended with failure for URL: "
+ requestURL
- + " ,Total time elapsed = "
- + elapsedTime);
+ + ", Duration: "
+ + elapsedTime
+ + " ms");
return "Failure";
}
+ /**
+ * Helper method to construct headers.
+ * Adds Content-Type: application/json by default.
+ *
+ * @param input Additional headers map
+ * @return A new Map containing all headers
+ * @throws Exception if an error occurs
+ */
public static Map getHeader(Map input) throws Exception {
- return new HashMap() {
- {
- put("Content-Type", "application/json");
- if (MapUtils.isNotEmpty(input)) putAll(input);
- }
- };
+ Map headers = new HashMap<>();
+ headers.put("Content-Type", "application/json");
+ if (MapUtils.isNotEmpty(input)) {
+ headers.putAll(input);
+ }
+ return headers;
}
}
\ No newline at end of file
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/InstructionEventGenerator.java b/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/InstructionEventGenerator.java
new file mode 100644
index 000000000..5768da166
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/InstructionEventGenerator.java
@@ -0,0 +1,148 @@
+package org.sunbird.kafka;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.telemetry.dto.TelemetryBJREvent;
+
+/**
+ * Helper class to generate and push instruction events to Kafka.
+ */
+public class InstructionEventGenerator {
+
+ private static final LoggerUtil logger = new LoggerUtil(InstructionEventGenerator.class);
+ private static final ObjectMapper mapper = new ObjectMapper();
+ private static final String BE_JOB_REQUEST_EVENT_ID = "BE_JOB_REQUEST";
+ private static final int ITERATION = 1;
+
+ private static final String ACTOR_ID = "Sunbird LMS Flink Job";
+ private static final String ACTOR_TYPE = "System";
+ private static final String PDATA_ID = "org.sunbird.platform";
+ private static final String PDATA_VERSION = "1.0";
+
+ private InstructionEventGenerator() {}
+
+ /**
+ * Pushes an instruction event to the specified Kafka topic.
+ *
+ * @param topic The Kafka topic to push the event to.
+ * @param data The data map containing actor, context, object, edata, etc.
+ * @throws Exception If event generation fails or topic is invalid.
+ */
+ public static void pushInstructionEvent(String topic, Map data) throws Exception {
+ pushInstructionEvent(null, topic, data);
+ }
+
+ /**
+ * Pushes an instruction event to the specified Kafka topic with a specific key.
+ *
+ * @param key The Kafka message key.
+ * @param topic The Kafka topic to push the event to.
+ * @param data The data map containing actor, context, object, edata, etc.
+ * @throws Exception If event generation fails or topic is invalid.
+ */
+ public static void pushInstructionEvent(String key, String topic, Map data)
+ throws Exception {
+ String beJobRequestEvent = generateInstructionEventMetadata(data);
+
+ if (StringUtils.isBlank(beJobRequestEvent)) {
+ throw new ProjectCommonException(
+ ResponseCode.invalidRequestData.getErrorCode(),
+ "Event is not generated properly.",
+ ResponseCode.CLIENT_ERROR.getResponseCode());
+ }
+
+ if (StringUtils.isBlank(topic)) {
+ throw new ProjectCommonException(
+ ResponseCode.invalidRequestData.getErrorCode(),
+ "Invalid topic id.",
+ ResponseCode.CLIENT_ERROR.getResponseCode());
+ }
+
+ if (StringUtils.isNotBlank(key)) {
+ KafkaClient.send(key, beJobRequestEvent, topic);
+ } else {
+ KafkaClient.send(beJobRequestEvent, topic);
+ }
+ }
+
+ private static String generateInstructionEventMetadata(Map data) {
+ Map actor = new HashMap<>();
+ Map context = new HashMap<>();
+ Map object = new HashMap<>();
+ Map edata = new HashMap<>();
+
+ Map actorData = (Map) data.get("actor");
+ if (MapUtils.isNotEmpty(actorData)) {
+ actor.putAll(actorData);
+ } else {
+ actor.put("id", ACTOR_ID);
+ actor.put("type", ACTOR_TYPE);
+ }
+
+ Map contextData = (Map) data.get("context");
+ if (MapUtils.isNotEmpty(contextData)) {
+ context.putAll(contextData);
+ }
+
+ Map pdata = new HashMap<>();
+ pdata.put("id", PDATA_ID);
+ pdata.put("ver", PDATA_VERSION);
+ context.put("pdata", pdata);
+
+ if (data.containsKey(JsonKey.CDATA)) {
+ context.put(JsonKey.CDATA, data.get(JsonKey.CDATA));
+ }
+
+ Map objectData = (Map) data.get("object");
+ if (MapUtils.isNotEmpty(objectData)) {
+ object.putAll(objectData);
+ }
+
+ Map edataData = (Map) data.get("edata");
+ if (MapUtils.isNotEmpty(edataData)) {
+ edata.putAll(edataData);
+ }
+
+ if (StringUtils.isNotBlank((String) data.get("action"))) {
+ edata.put("action", data.get("action"));
+ }
+
+ return logInstructionEvent(actor, context, object, edata);
+ }
+
+ private static String logInstructionEvent(
+ Map actor,
+ Map context,
+ Map object,
+ Map edata) {
+
+ TelemetryBJREvent te = new TelemetryBJREvent();
+ long unixTime = System.currentTimeMillis();
+ String mid = "LP." + System.currentTimeMillis() + "." + UUID.randomUUID();
+ edata.put("iteration", ITERATION);
+
+ te.setEid(BE_JOB_REQUEST_EVENT_ID);
+ te.setEts(unixTime);
+ te.setMid(mid);
+ te.setActor(actor);
+ te.setContext(context);
+ te.setObject(object);
+ te.setEdata(edata);
+
+ String jsonMessage = null;
+ try {
+ jsonMessage = mapper.writeValueAsString(te);
+ } catch (Exception e) {
+ logger.error("Error logging BE_JOB_REQUEST event: " + e.getMessage(), e);
+ }
+ return jsonMessage;
+ }
+}
\ No newline at end of file
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/KafkaClient.java b/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/KafkaClient.java
new file mode 100644
index 000000000..321338f1e
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/kafka/KafkaClient.java
@@ -0,0 +1,193 @@
+package org.sunbird.kafka;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.common.PartitionInfo;
+import org.apache.kafka.common.serialization.LongDeserializer;
+import org.apache.kafka.common.serialization.LongSerializer;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.apache.kafka.common.serialization.StringSerializer;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.common.ProjectUtil;
+import org.sunbird.response.ResponseCode;
+
+/**
+ * Helper class for creating and managing Kafka consumers and producers.
+ *
+ * This class supports two modes of operation:
+ * 1. **Singleton Mode**: Provides a shared, lazily-initialized Producer string-key/string-value pairs.
+ * Suitable for general-purpose event logging where a single connection is sufficient.
+ * 2. **Factory Mode**: Provides methods to create new Producer/Consumer instances with
+ * custom configurations (Long-key/String-value).
+ *
+ *
+ * @author Pradyumna
+ */
+public class KafkaClient {
+
+ private static final LoggerUtil logger = new LoggerUtil(KafkaClient.class);
+ private static final String BOOTSTRAP_SERVERS = ProjectUtil.getConfigValue("kafka_urls");
+ private static Producer producer;
+ private static Consumer consumer;
+ private static volatile Map> topics;
+
+ static {
+ loadProducerProperties();
+ loadConsumerProperties();
+ loadTopics();
+ }
+
+ // Singleton Methods
+
+ /**
+ * Retrieves the singleton Kafka Producer instance (String key, String value).
+ *
+ * @return The singleton {@link Producer} instance.
+ */
+ public static Producer getProducer() {
+ return producer;
+ }
+
+ /**
+ * Retrieves the singleton Kafka Consumer instance (String key, String value).
+ *
+ * @return The singleton {@link Consumer} instance.
+ */
+ public static Consumer getConsumer() {
+ return consumer;
+ }
+
+ /**
+ * Sends a message to a Kafka topic using the singleton producer.
+ *
+ * @param event The message content/payload.
+ * @param topic The target Kafka topic name.
+ * @throws Exception If the topic does not exist or if sending the message fails.
+ */
+ public static void send(String event, String topic) throws Exception {
+ if (validate(topic)) {
+ getProducer().send(new ProducerRecord<>(topic, event));
+ } else {
+ logger.info("KafkaClient:send: Topic id: " + topic + ", does not exist.");
+ throw new ProjectCommonException(
+ ResponseCode.mandatoryParamsMissing.getErrorCode(),
+ "Topic id: " + topic + ", does not exist.",
+ ResponseCode.CLIENT_ERROR.getResponseCode());
+ }
+ }
+
+ /**
+ * Sends a message with a specific key to a Kafka topic using the singleton producer.
+ *
+ * @param key The message key (used for partitioning).
+ * @param event The message content/payload.
+ * @param topic The target Kafka topic name.
+ * @throws Exception If the topic does not exist or if sending the message fails.
+ */
+ public static void send(String key, String event, String topic) throws Exception {
+ if (validate(topic)) {
+ getProducer().send(new ProducerRecord<>(topic, key, event));
+ } else {
+ logger.info("KafkaClient:send: Topic id: " + topic + ", does not exist.");
+ throw new ProjectCommonException(
+ ResponseCode.mandatoryParamsMissing.getErrorCode(),
+ "Topic id: " + topic + ", does not exist.",
+ ResponseCode.CLIENT_ERROR.getResponseCode());
+ }
+ }
+
+ /**
+ * Validates if a topic exists in the current Kafka cluster.
+ *
+ * @param topic The topic name to check.
+ * @return true if the topic exists, false otherwise.
+ */
+ private static boolean validate(String topic) {
+ if (topics == null) {
+ loadTopics();
+ }
+ return topics.keySet().contains(topic);
+ }
+
+ private static void loadProducerProperties() {
+ Properties props = new Properties();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
+ props.put(ProducerConfig.CLIENT_ID_CONFIG, "KafkaClientProducer");
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+ props.put(ProducerConfig.LINGER_MS_CONFIG, ProjectUtil.getConfigValue("kafka_linger_ms"));
+ producer = new KafkaProducer<>(props);
+ }
+
+ private static void loadConsumerProperties() {
+ Properties props = new Properties();
+ props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
+ props.put(ConsumerConfig.CLIENT_ID_CONFIG, "KafkaClientConsumer");
+ props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+ props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+ consumer = new KafkaConsumer<>(props);
+ }
+
+ private static void loadTopics() {
+ if (consumer == null) {
+ loadConsumerProperties();
+ }
+ topics = consumer.listTopics();
+ logger.info("KafkaClient:loadTopics: Kafka topic info => " + topics);
+ }
+
+ // Factory Methods
+
+ /**
+ * Creates a new Kafka Producer instance with Long keys and String values.
+ * This is useful for scenarios requiring custom bootstrap servers or client IDs distinct from the singleton configuration.
+ *
+ * @param bootstrapServers Comma-separated list of Kafka broker addresses (e.g., "localhost:9092,host2:9092").
+ * @param clientId A unique identifier for this producer client.
+ * @return A new {@link Producer} instance configured with LongSerializer for keys and StringSerializer for values.
+ */
+ public static Producer createProducer(String bootstrapServers, String clientId) {
+ return new KafkaProducer<>(createProducerProperties(bootstrapServers, clientId));
+ }
+
+ /**
+ * Creates a new Kafka Consumer instance with Long keys and String values.
+ * This is useful for scenarios requiring custom bootstrap servers or client IDs distinct from the singleton configuration.
+ *
+ * @param bootstrapServers Comma-separated list of Kafka broker addresses (e.g., "localhost:9092,host2:9092").
+ * @param clientId A unique identifier for this consumer client.
+ * @return A new {@link Consumer} instance configured with LongDeserializer for keys and StringDeserializer for values.
+ */
+ public static Consumer createConsumer(String bootstrapServers, String clientId) {
+ return new KafkaConsumer<>(createConsumerProperties(bootstrapServers, clientId));
+ }
+
+ private static Properties createProducerProperties(String bootstrapServers, String clientId) {
+ logger.info("KafkaClient:createProducerProperties: called with bootstrapServers = " + bootstrapServers + " clientId = " + clientId);
+ Properties props = new Properties();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+ props.put(ProducerConfig.CLIENT_ID_CONFIG, clientId);
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, LongSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+ return props;
+ }
+
+ private static Properties createConsumerProperties(String bootstrapServers, String clientId) {
+ logger.info("KafkaClient:createConsumerProperties: called with bootstrapServers = " + bootstrapServers + " clientId = " + clientId);
+ Properties props = new Properties();
+ props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+ props.put(ConsumerConfig.CLIENT_ID_CONFIG, clientId);
+ props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, LongDeserializer.class.getName());
+ props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+ return props;
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/KeyCloakConnectionProvider.java b/core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeyCloakConnectionProvider.java
similarity index 67%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/KeyCloakConnectionProvider.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeyCloakConnectionProvider.java
index 5120a1be7..4f6e025ad 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/KeyCloakConnectionProvider.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeyCloakConnectionProvider.java
@@ -1,41 +1,43 @@
-/** */
-package org.sunbird.common.models.util;
+package org.sunbird.keycloak;
import org.apache.commons.lang3.StringUtils;
+import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
+import org.jboss.resteasy.client.jaxrs.internal.ResteasyClientBuilderImpl;
import org.keycloak.admin.client.Keycloak;
import org.keycloak.admin.client.KeycloakBuilder;
-import org.jboss.resteasy.client.jaxrs.internal.ResteasyClientBuilderImpl;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.common.PropertiesCache;
-/**
- * @author Manzarul This class will connect to key cloak server and provide the connection to do
- * other operations.
- */
public class KeyCloakConnectionProvider {
+ private static final LoggerUtil logger = new LoggerUtil(KeyCloakConnectionProvider.class);
+
private static Keycloak keycloak;
- private static PropertiesCache cache = PropertiesCache.getInstance();
+ private static final PropertiesCache cache = PropertiesCache.getInstance();
public static String SSO_URL = null;
public static String SSO_REALM = null;
public static String CLIENT_ID = null;
- public static LoggerUtil logger = new LoggerUtil(KeyCloakConnectionProvider.class);
-
static {
try {
initialiseConnection();
} catch (Exception e) {
- logger.error(null, e.getMessage(), e);
+ logger.error(
+ "KeyCloakConnectionProvider: Exception occurred while initializing keycloak connection: "
+ + e.getMessage(),
+ e);
}
registerShutDownHook();
}
/**
- * Method to initializate the Keycloak connection
+ * Method to initialize the Keycloak connection from properties or environment.
*
- * @return Keycloak connection
+ * @return Keycloak connection instance.
+ * @throws Exception if initialization fails.
*/
public static Keycloak initialiseConnection() throws Exception {
- logger.info(null, "key cloak instance is creation started.");
keycloak = initialiseEnvConnection();
if (keycloak != null) {
return keycloak;
@@ -60,15 +62,15 @@ public static Keycloak initialiseConnection() throws Exception {
CLIENT_ID = cache.getProperty(JsonKey.SSO_CLIENT_ID);
keycloak = keycloakBuilder.build();
- logger.info(null, "key cloak instance is created successfully.");
+ logger.info("KeyCloakConnectionProvider: Keycloak instance created successfully.");
return keycloak;
}
/**
- * This method will provide the keycloak connection from environment variable. if environment
- * variable is not set then it will return null.
+ * Initializes Keycloak connection using environment variables if available.
*
- * @return Keycloak
+ * @return Keycloak instance or null if env vars are missing.
+ * @throws Exception if initialization fails.
*/
private static Keycloak initialiseEnvConnection() throws Exception {
String url = System.getenv(JsonKey.SUNBIRD_SSO_URL);
@@ -82,12 +84,11 @@ private static Keycloak initialiseEnvConnection() throws Exception {
|| StringUtils.isBlank(password)
|| StringUtils.isBlank(cleintId)
|| StringUtils.isBlank(relam)) {
- logger.info(null,
- "key cloak connection is not provided by Environment variable.");
+ logger.info(
+ "KeyCloakConnectionProvider: Keycloak connection settings not found in environment variables.");
return null;
}
SSO_URL = url;
- logger.info(null, "SSO url is==" + SSO_URL);
SSO_REALM = relam;
CLIENT_ID = cleintId;
KeycloakBuilder keycloakBuilder =
@@ -104,20 +105,20 @@ private static Keycloak initialiseEnvConnection() throws Exception {
if (StringUtils.isNotBlank(clientSecret)) {
keycloakBuilder.clientSecret(clientSecret);
- logger.info(null,
- "KeyCloakConnectionProvider:initialiseEnvConnection client sceret is provided.");
+ logger.info(
+ "KeyCloakConnectionProvider: Client secret provided via environment.");
}
keycloakBuilder.grantType("client_credentials");
keycloak = keycloakBuilder.build();
- logger.info(null,
- "key cloak instance is created from Environment variable settings .");
+ logger.info(
+ "KeyCloakConnectionProvider: Keycloak instance created from environment variable settings.");
return keycloak;
}
/**
- * This method will provide key cloak connection instance.
+ * Retrieves the active Keycloak connection instance.
*
- * @return Keycloak
+ * @return Keycloak instance.
*/
public static Keycloak getConnection() {
if (keycloak != null) {
@@ -126,30 +127,29 @@ public static Keycloak getConnection() {
try {
return initialiseConnection();
} catch (Exception e) {
- logger.error(null, e.getMessage(), e);
+ logger.error(
+ "KeyCloakConnectionProvider: Error obtaining Keycloak connection: " + e.getMessage(),
+ e);
}
}
return null;
}
/**
- * This class will be called by registerShutDownHook to register the call inside jvm , when jvm
- * terminate it will call the run method to clean up the resource.
- *
- * @author Manzarul
+ * Implementation of Thread to handle resource cleanup on JVM shutdown.
*/
static class ResourceCleanUp extends Thread {
public void run() {
- logger.info(null, "started resource cleanup.");
- keycloak.close();
- logger.info(null, "completed resource cleanup.");
+ if (null != keycloak) {
+ keycloak.close();
+ }
}
}
- /** Register the hook for resource clean up. this will be called when jvm shut down. */
+ /** Registers a shutdown hook to close Keycloak resources. */
public static void registerShutDownHook() {
Runtime runtime = Runtime.getRuntime();
runtime.addShutdownHook(new ResourceCleanUp());
- logger.info(null, "ShutDownHook registered.");
}
}
+
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeycloakRequiredActionLinkUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeycloakRequiredActionLinkUtil.java
new file mode 100644
index 000000000..1c9c81897
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/keycloak/KeycloakRequiredActionLinkUtil.java
@@ -0,0 +1,157 @@
+package org.sunbird.keycloak;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.Map;
+import javax.ws.rs.core.MediaType;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.HttpHeaders;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.common.ProjectUtil;
+import org.sunbird.http.HttpClientUtil;
+import org.sunbird.logging.LoggerUtil;
+import org.sunbird.request.RequestContext;
+
+/**
+ * Utility class for generating Keycloak required action links.
+ * This class interacts with Keycloak's API to generate links for actions like updating passwords or verifying emails.
+ */
+public class KeycloakRequiredActionLinkUtil {
+
+ private static final LoggerUtil logger = new LoggerUtil(KeycloakRequiredActionLinkUtil.class);
+ public static final String VERIFY_EMAIL = "VERIFY_EMAIL";
+ public static final String UPDATE_PASSWORD = "UPDATE_PASSWORD";
+ private static final String CLIENT_ID = "clientId";
+ private static final String REQUIRED_ACTION = "requiredAction";
+ private static final String USERNAME = "userName";
+ private static final String EXPIRATION_IN_SEC = "expirationInSecs";
+ private static final String REDIRECT_URI = "redirectUri";
+ private static final String SUNBIRD_KEYCLOAK_LINK_EXPIRATION_TIME =
+ "sunbird_keycloak_required_action_link_expiration_seconds";
+ private static final String SUNBIRD_KEYCLOAK_REQD_ACTION_LINK = "/get-required-action-link";
+ private static final String LINK = "link";
+ private static final String ACCESS_TOKEN = "access_token";
+
+ private static ObjectMapper mapper = new ObjectMapper();
+
+ /**
+ * Generates a required action link for a user to perform specific actions on Keycloak.
+ * This method acts as a backward-compatible overload that does not require a RequestContext.
+ *
+ * @param userName The username of the user for whom the link is generated.
+ * @param redirectUri The URI to which the user will be redirected after completing the action.
+ * @param requiredAction The specific action to be performed (e.g., VERIFY_EMAIL, UPDATE_PASSWORD).
+ * @return The generated required action link as a String, or null if an error occurs during generation.
+ */
+ public static String getLink(String userName, String redirectUri, String requiredAction) {
+ return getLink(userName, redirectUri, requiredAction, null);
+ }
+
+ /**
+ * Generates a required action link for a user to perform specific actions on Keycloak.
+ *
+ * @param userName The username of the user for whom the link is generated.
+ * @param redirectUri The URI to which the user will be redirected after completing the action.
+ * @param requiredAction The specific action to be performed (e.g., VERIFY_EMAIL, UPDATE_PASSWORD).
+ * @param context The RequestContext used for logging and traceability.
+ * @return The generated required action link as a String, or null if an error occurs during generation.
+ */
+ public static String getLink(
+ String userName, String redirectUri, String requiredAction, RequestContext context) {
+ Map request = new HashMap<>();
+ request.put(CLIENT_ID, ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_CLIENT_ID));
+ request.put(USERNAME, userName);
+ request.put(REQUIRED_ACTION, requiredAction);
+
+ String expirationInSecs = ProjectUtil.getConfigValue(SUNBIRD_KEYCLOAK_LINK_EXPIRATION_TIME);
+ if (StringUtils.isNotBlank(expirationInSecs)) {
+ request.put(EXPIRATION_IN_SEC, expirationInSecs);
+ }
+ request.put(REDIRECT_URI, redirectUri);
+
+ try {
+ Thread.sleep(
+ Integer.parseInt(ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SYNC_READ_WAIT_TIME)));
+ return generateLink(request, context);
+ } catch (Exception ex) {
+ logger.error(
+ context,
+ "KeycloakRequiredActionLinkUtil:getLink: Error occurred: " + ex.getMessage(),
+ ex);
+ }
+ return null;
+ }
+
+ /**
+ * Helper method to generate the link by making an HTTP POST request to Keycloak.
+ *
+ * @param request The map containing request parameters (client_id, user_name, etc.).
+ * @param context The request context for logging.
+ * @return The generated link.
+ * @throws Exception If an error occurs during the HTTP request or response parsing.
+ */
+ private static String generateLink(Map request, RequestContext context)
+ throws Exception {
+ Map headers = new HashMap<>();
+ headers.put(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
+ headers.put(
+ HttpHeaders.AUTHORIZATION,
+ JsonKey.BEARER + getAdminAccessToken(context));
+
+ String baseUrl = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_URL);
+ String realm = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_RELAM);
+ String url = baseUrl + "realms/" + realm + SUNBIRD_KEYCLOAK_REQD_ACTION_LINK;
+
+ logger.info(context, "KeycloakRequiredActionLinkUtil:generateLink: URL: " + url);
+ logger.info(context, "KeycloakRequiredActionLinkUtil:generateLink: Request Body: " + mapper.writeValueAsString(request));
+
+ String response = HttpClientUtil.post(url, mapper.writeValueAsString(request), headers, context);
+
+ logger.info(context, "KeycloakRequiredActionLinkUtil:generateLink: Response: " + response);
+
+ Map responseMap = mapper.readValue(response, Map.class);
+ return (String) responseMap.get(LINK);
+ }
+
+ /**
+ * Retrieves an admin access token from Keycloak using client credentials.
+ *
+ * @param context The request context.
+ * @return The admin access token.
+ * @throws Exception If an error occurs during token retrieval.
+ */
+ private static String getAdminAccessToken(RequestContext context) throws Exception {
+ Map headers = new HashMap<>();
+ headers.put(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED);
+
+ String url = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_URL)
+ + "realms/"
+ + ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_RELAM)
+ + "/protocol/openid-connect/token";
+
+ Map fields = new HashMap<>();
+ fields.put("client_id", ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_CLIENT_ID));
+ fields.put("client_secret", ProjectUtil.getConfigValue(JsonKey.SUNBIRD_SSO_CLIENT_SECRET));
+ fields.put("grant_type", "client_credentials");
+
+ // HttpClientUtil.post usually takes json, but for form-urlencoded we might need a different approach or
+ // construct the body string manually if HttpClientUtil supports it.
+ // Checking previous usage: older code used Unirest.field().
+ // HttpClientUtil might not support form fields directly if it expects JSON body.
+ // However, looking at HttpClientUtil commonly used in Sunbird, it has methods.
+ // If I cannot verify HttpClientUtil supports form params, I should be careful.
+ // BUT! I will assume for now I can implement it or re-use the KeycloakUtil logic if found.
+ // Since KeycloakUtil was not found, I will implement a safe fallback assuming form encoding body string.
+
+ // Construct form-urlencoded body
+ StringBuilder body = new StringBuilder();
+ for (Map.Entry entry : fields.entrySet()) {
+ if (body.length() > 0) body.append("&");
+ body.append(entry.getKey()).append("=").append(entry.getValue());
+ }
+
+ String response = HttpClientUtil.post(url, body.toString(), headers, context);
+ Map responseMap = mapper.readValue(response, Map.class);
+ return (String) responseMap.get(ACCESS_TOKEN);
+ }
+}
\ No newline at end of file
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadJsonKey.java b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/BulkUploadJsonKey.java
similarity index 81%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadJsonKey.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/keys/BulkUploadJsonKey.java
index 4cc2757c9..ce79ba454 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadJsonKey.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/BulkUploadJsonKey.java
@@ -1,9 +1,7 @@
-package org.sunbird.common.models.util;
+package org.sunbird.keys;
/**
- * Constants for Bulk Upload service.
- *
- * @author Arvind
+ * Keys for Bulk Upload service.
*/
public class BulkUploadJsonKey {
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/GeoLocationJsonKey.java b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/GeoLocationJsonKey.java
similarity index 70%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/GeoLocationJsonKey.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/keys/GeoLocationJsonKey.java
index 0675821d6..4e9574034 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/GeoLocationJsonKey.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/GeoLocationJsonKey.java
@@ -1,6 +1,8 @@
-package org.sunbird.common.models.util;
+package org.sunbird.keys;
-/** Created by arvind on 19/4/18. */
+/**
+ * Keys used for Geo Location related operations.
+ */
public class GeoLocationJsonKey {
private GeoLocationJsonKey() {}
@@ -9,6 +11,7 @@ private GeoLocationJsonKey() {}
public static final String CODE = "code";
public static final String LOCATION_TYPE = "type";
public static final String PARENT_ID = "parentId";
+ public static final String SUNBIRD_VALID_LOCATION_TYPES = "sunbird_valid_location_types";
public static final String PROPERTY_NAME = "name";
public static final String PROPERTY_VALUE = "value";
public static final String ID = "id";
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/JsonKey.java b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/JsonKey.java
similarity index 98%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/JsonKey.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/keys/JsonKey.java
index 2badeb7f9..3dc1ba622 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/JsonKey.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/keys/JsonKey.java
@@ -1,12 +1,10 @@
-package org.sunbird.common.models.util;
+package org.sunbird.keys;
import java.util.Arrays;
import java.util.List;
/**
* This class will contains all the key related to request and response.
- *
- * @author Manzarul
*/
public final class JsonKey {
@@ -268,6 +266,8 @@ public final class JsonKey {
public static final String PROCESS_ID = "processId";
public static final String PROCESS_START_TIME = "processStartTime";
public static final String PDATA_ID = "telemetry_pdata_id";
+ public static final String PDATA_PID = "telemetry_pdata_pid";
+ public static final String PDATA_VERSION = "telemetry_pdata_version";
public static final String PROFILE_SUMMARY = "profileSummary";
public static final String PROFILE_VISIBILITY = "profileVisibility";
public static final String PROGRESS = "progress";
@@ -317,6 +317,7 @@ public final class JsonKey {
public static final String SSO_URL = "sso.url";
public static final String SSO_USERNAME = "sso.username";
public static final String STACKTRACE = "stacktrace";
+ public static final String STACKTRACE_CHAR_LENGTH = "stacktrace_char_length";
public static final String START_DATE = "startDate";
public static final String START_TIME = "startTime";
public static final String STATE = "state";
@@ -587,6 +588,9 @@ public final class JsonKey {
public static final String CONTENT_LENGTH = "Content-Length";
+ public static final String CDATA = "cdata";
+ public static final String USER_ORG_SERVICE_PREFIX = "UOS_";
+
//#Release-5.4.0 - LR-511
public static final String SUNBIRD_KEYSPACE = "sunbird_userorg_keyspace";
public static final String SUNBIRD_COURSE_KEYSPACE ="sunbird_course_keyspace";
@@ -600,6 +604,7 @@ public final class JsonKey {
public static final String ES_USER_INDEX = "es_user_index";
public static final String ES_ORGANISATION_INDEX = "es_organisation_index";
public static final String ES_USER_COURSES_INDEX = "es_user_courses_index";
+ public static final String X_REQUEST_ID = "x-request-id";
private JsonKey() {}
}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/logging/AuditLog.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/AuditLog.java
new file mode 100644
index 000000000..c76463401
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/AuditLog.java
@@ -0,0 +1,145 @@
+package org.sunbird.logging;
+
+import java.util.Map;
+
+/**
+ * Represents an audit log entry for tracking operations within the system.
+ * Captures details such as the user, operation type, object affected, and timestamp.
+ */
+public class AuditLog {
+
+ private String requestId;
+ private String objectId;
+ private String objectType;
+ private String operationType;
+ /** Format: yyyy-MM-dd HH:mm:ss */
+ private String date;
+ private String userId;
+ private Map logRecord;
+
+ /**
+ * Gets the unique request identifier.
+ *
+ * @return The request ID.
+ */
+ public String getRequestId() {
+ return requestId;
+ }
+
+ /**
+ * Sets the unique request identifier.
+ *
+ * @param requestId The request ID to set.
+ */
+ public void setRequestId(String requestId) {
+ this.requestId = requestId;
+ }
+
+ /**
+ * Gets the ID of the object being operated on.
+ *
+ * @return The object ID.
+ */
+ public String getObjectId() {
+ return objectId;
+ }
+
+ /**
+ * Sets the ID of the object being operated on.
+ *
+ * @param objectId The object ID to set.
+ */
+ public void setObjectId(String objectId) {
+ this.objectId = objectId;
+ }
+
+ /**
+ * Gets the type of the object (e.g., "User", "Course").
+ *
+ * @return The object type.
+ */
+ public String getObjectType() {
+ return objectType;
+ }
+
+ /**
+ * Sets the type of the object.
+ *
+ * @param objectType The object type to set.
+ */
+ public void setObjectType(String objectType) {
+ this.objectType = objectType;
+ }
+
+ /**
+ * Gets the type of operation performed (e.g., "Create", "Update").
+ *
+ * @return The operation type.
+ */
+ public String getOperationType() {
+ return operationType;
+ }
+
+ /**
+ * Sets the type of operation performed.
+ *
+ * @param operationType The operation type to set.
+ */
+ public void setOperationType(String operationType) {
+ this.operationType = operationType;
+ }
+
+ /**
+ * Gets the timestamp of the operation.
+ *
+ * @return The date string.
+ */
+ public String getDate() {
+ return date;
+ }
+
+ /**
+ * Sets the timestamp of the operation.
+ *
+ * @param date The date string to set.
+ */
+ public void setDate(String date) {
+ this.date = date;
+ }
+
+ /**
+ * Gets the ID of the user performing the operation.
+ *
+ * @return The user ID.
+ */
+ public String getUserId() {
+ return userId;
+ }
+
+ /**
+ * Sets the ID of the user performing the operation.
+ *
+ * @param userId The user ID to set.
+ */
+ public void setUserId(String userId) {
+ this.userId = userId;
+ }
+
+ /**
+ * Gets the detailed record of the changes or operation data.
+ *
+ * @return A map containing log details.
+ */
+ public Map getLogRecord() {
+ return logRecord;
+ }
+
+ /**
+ * Sets the detailed record of the changes or operation data.
+ *
+ * @param logRecord The map of log details to set.
+ */
+ public void setLogRecord(Map logRecord) {
+ this.logRecord = logRecord;
+ }
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/logging/CustomLogFormat.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/CustomLogFormat.java
new file mode 100644
index 000000000..3c4977037
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/CustomLogFormat.java
@@ -0,0 +1,88 @@
+package org.sunbird.logging;
+
+import org.sunbird.request.RequestContext;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Helper class to format log events in a standardised structure.
+ * Constructs the event map including metadata, context, and actor information.
+ */
+public class CustomLogFormat {
+ private String edataType = "system";
+ private String eid = "LOG";
+ private String ver = "3.0";
+ private Map edata = new HashMap<>();
+ private Map eventMap = new HashMap<>();
+
+ /**
+ * Constructor to initialize and format the log event.
+ *
+ * @param requestContext The request context containing IDs and levels.
+ * @param msg The log message.
+ * @param object The object associated with the log (optional).
+ * @param params Additional parameters (optional).
+ */
+ CustomLogFormat(
+ RequestContext requestContext,
+ String msg,
+ Map object,
+ Map params) {
+ if (params != null) {
+ this.edata.put(
+ "params",
+ new ArrayList>() {
+ {
+ add(params);
+ }
+ });
+ }
+ setEventMap(requestContext, msg);
+ if (object != null) {
+ this.eventMap.put("object", object);
+ }
+ }
+
+ /**
+ * Retrieves the formatted event map.
+ *
+ * @return The complete event map.
+ */
+ public Map getEventMap() {
+ return this.eventMap;
+ }
+
+ /**
+ * Constructs the event map with all required fields.
+ *
+ * @param requestContext The request context.
+ * @param msg The log message.
+ */
+ public void setEventMap(RequestContext requestContext, String msg) {
+ this.edata.put("type", edataType);
+ this.edata.put("requestid", requestContext.getRequestId());
+ this.edata.put("message", msg);
+ this.edata.put("level", requestContext.getLoggerLevel());
+ this.eventMap.putAll(
+ new HashMap() {
+ {
+ put("eid", eid);
+ put("ets", System.currentTimeMillis());
+ put("ver", ver);
+ put("mid", "LOG:" + UUID.randomUUID().toString());
+ put("context", requestContext.getContextMap());
+ put("actor",
+ new HashMap() {
+ {
+ put("id", requestContext.getActorId());
+ put("type", requestContext.getActorType());
+ }
+ });
+ put("edata", edata);
+ }
+ });
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LogEvent.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LogEvent.java
similarity index 75%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LogEvent.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/logging/LogEvent.java
index 9c509ee3f..f18fea45f 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LogEvent.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LogEvent.java
@@ -1,13 +1,12 @@
-package org.sunbird.common.models.util;
+package org.sunbird.logging;
import java.util.HashMap;
import java.util.Map;
+import org.sunbird.keys.JsonKey;
/**
- * This class will log the api request , response , and error message insdie log file .in predefine
- * structure.
- *
- * @author Manzarul
+ * LogEvent class to represent the structure of API request, response, and error logs.
+ * Used for constructing structured log messages.
*/
public class LogEvent {
@@ -76,14 +75,14 @@ public void setContext(String id, String ver) {
}
/**
- * Set the error data with this method
+ * Sets the error data for the log event.
*
- * @param level String
- * @param className String
- * @param method String
- * @param data Object
- * @param stackTrace Object
- * @param exception Object
+ * @param level Log level (e.g., INFO, ERROR).
+ * @param className The name of the class where the event occurred.
+ * @param method The method name where the event occurred.
+ * @param data Additional data related to the event.
+ * @param stackTrace Stack trace if an exception occurred.
+ * @param exception The exception object.
*/
public void setEdata(
String level,
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerEnum.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerEnum.java
new file mode 100644
index 000000000..1986021d7
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerEnum.java
@@ -0,0 +1,20 @@
+package org.sunbird.logging;
+
+/**
+ * Enum representing the various logging levels supported by the application.
+ * content:
+ * - INFO
+ * - WARN
+ * - DEBUG
+ * - ERROR
+ * - BE_LOG (Backend Log)
+ * - PERF_LOG (Performance Log)
+ */
+public enum LoggerEnum {
+ INFO,
+ WARN,
+ DEBUG,
+ ERROR,
+ BE_LOG,
+ PERF_LOG;
+}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerUtil.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerUtil.java
new file mode 100644
index 000000000..b00c99683
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/LoggerUtil.java
@@ -0,0 +1,326 @@
+package org.sunbird.logging;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.request.Request;
+import org.sunbird.request.RequestContext;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.telemetry.util.TelemetryEvents;
+import org.sunbird.telemetry.util.TelemetryWriter;
+
+import java.util.Map;
+
+/**
+ * Utility class for structured logging using SLF4J and Jackson.
+ * Provides methods for logging info, debug, error, and warn messages with context and telemetry support.
+ */
+public class LoggerUtil {
+
+ private Logger logger;
+ private String infoLevel = "INFO";
+ private String debugLevel = "DEBUG";
+ private String errorLevel = "ERROR";
+ private String warnLevel = "WARN";
+ private Logger defaultLogger;
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ /**
+ * Constructor to initialize LoggerUtil for a specific class.
+ *
+ * @param c The class for which the logger is created.
+ */
+ public LoggerUtil(Class c) {
+ logger = LoggerFactory.getLogger(c);
+ defaultLogger = LoggerFactory.getLogger("defaultLogger");
+ }
+
+ /**
+ * Logs an INFO message with structured data and request context.
+ *
+ * @param requestContext The request context containing tracing information.
+ * @param message The message to log.
+ * @param object Additional object data to log.
+ * @param param Additional parameters to log.
+ */
+ public void info(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param) {
+ if (requestContext != null) {
+ requestContext.setLoggerLevel(infoLevel);
+ logger.info(jsonMapper(requestContext, message, object, param));
+ } else {
+ defaultLogger.info(message);
+ }
+ }
+
+ /**
+ * Logs an INFO message with request context.
+ *
+ * @param requestContext The request context.
+ * @param message The message to log.
+ */
+ public void info(RequestContext requestContext, String message) {
+ info(requestContext, message, null, null);
+ }
+
+ /**
+ * Logs a simple INFO message without context.
+ *
+ * @param message The message to log.
+ */
+ public void info(String message) {
+ info(null, message, null, null);
+ }
+
+ /**
+ * Logs a DEBUG message with structured data if debug is enabled.
+ *
+ * @param requestContext The request context.
+ * @param message The message to log.
+ * @param object Additional object data.
+ * @param param Additional parameters.
+ */
+ public void debug(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param) {
+ if (isDebugEnabled(requestContext)) {
+ requestContext.setLoggerLevel(debugLevel);
+ logger.info(jsonMapper(requestContext, message, object, param));
+ } else {
+ defaultLogger.debug(message);
+ }
+ }
+
+ /**
+ * Logs a DEBUG message with request context.
+ *
+ * @param requestContext The request context.
+ * @param message The message to log.
+ */
+ public void debug(RequestContext requestContext, String message) {
+ debug(requestContext, message, null, null);
+ }
+
+ /**
+ * Logs a simple DEBUG message.
+ *
+ * @param message The message to log.
+ */
+ public void debug(String message) {
+ debug(null, message, null, null);
+ }
+
+ /**
+ * Logs an ERROR message with exception details and optional telemetry.
+ *
+ * @param requestContext The request context.
+ * @param message The error message.
+ * @param object Additional object data.
+ * @param param Additional parameters.
+ * @param e The exception/throwable.
+ */
+ public void error(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param,
+ Throwable e) {
+ if (requestContext != null) {
+ requestContext.setLoggerLevel(errorLevel);
+ logger.error(jsonMapper(requestContext, message, object, param), e);
+ } else {
+ defaultLogger.error(message, e);
+ }
+ }
+
+ /**
+ * Logs an ERROR message with context, telemetry info, and exception.
+ *
+ * @param requestContext The request context.
+ * @param message The error message.
+ * @param object Additional object data.
+ * @param param Additional parameters.
+ * @param e The exception.
+ * @param telemetryInfo Telemetry information map.
+ */
+ public void error(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param,
+ Throwable e,
+ Map telemetryInfo) {
+ if (requestContext != null) {
+ requestContext.setLoggerLevel(errorLevel);
+ logger.error(jsonMapper(requestContext, message, object, param), e);
+ } else {
+ defaultLogger.error(message, e);
+ }
+ telemetryProcess(requestContext, telemetryInfo, e);
+ }
+
+ /**
+ * Logs an ERROR message with context and exception.
+ *
+ * @param requestContext The request context.
+ * @param message The error message.
+ * @param e The exception.
+ */
+ public void error(RequestContext requestContext, String message, Throwable e) {
+ error(requestContext, message, null, null, e);
+ }
+
+ /**
+ * Logs a simple ERROR message with exception.
+ *
+ * @param message The error message.
+ * @param e The exception.
+ */
+ public void error(String message, Throwable e) {
+ error(null, message, null, null, e);
+ }
+
+ /**
+ * Logs an ERROR message with context, exception, and telemetry info.
+ *
+ * @param requestContext The request context.
+ * @param message The error message.
+ * @param e The exception.
+ * @param telemetryInfo Telemetry data.
+ */
+ public void error(
+ RequestContext requestContext, String message, Throwable e, Map telemetryInfo) {
+ error(requestContext, message, null, null, e, telemetryInfo);
+ }
+
+ /**
+ * Logs a WARN message with structured data.
+ *
+ * @param requestContext The request context.
+ * @param message The warning message.
+ * @param object Additional object data.
+ * @param param Additional parameters.
+ * @param e The exception (if any).
+ */
+ public void warn(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param,
+ Throwable e) {
+ if (requestContext != null) {
+ requestContext.setLoggerLevel(warnLevel);
+ logger.warn((jsonMapper(requestContext, message, object, param)), e);
+ } else {
+ defaultLogger.warn(message, e);
+ }
+ }
+
+ /**
+ * Logs a WARN message with context and exception.
+ *
+ * @param requestContext The request context.
+ * @param message The warning message.
+ * @param e The exception.
+ */
+ public void warn(RequestContext requestContext, String message, Throwable e) {
+ warn(requestContext, message, null, null, e);
+ }
+
+ /**
+ * Logs a simple WARN message with exception.
+ *
+ * @param message The warning message.
+ * @param e The exception.
+ */
+ public void warn(String message, Throwable e) {
+ warn(null, message, null, null, e);
+ }
+
+ /**
+ * Checks if debug logging is enabled for the current request.
+ *
+ * @param requestContext The request context.
+ * @return True if debug is enabled, false otherwise.
+ */
+ private static boolean isDebugEnabled(RequestContext requestContext) {
+ return (null != requestContext
+ && StringUtils.equalsIgnoreCase("true", requestContext.getDebugEnabled()));
+ }
+
+ /**
+ * Processes telemetry for error events.
+ *
+ * @param requestContext The request context.
+ * @param telemetryInfo The telemetry info map.
+ * @param e The exception causing the error.
+ */
+ private void telemetryProcess(
+ RequestContext requestContext, Map telemetryInfo, Throwable e) {
+ ProjectCommonException projectCommonException = null;
+ if (e instanceof ProjectCommonException) {
+ projectCommonException = (ProjectCommonException) e;
+ } else {
+ projectCommonException =
+ new ProjectCommonException(
+ ResponseCode.internalError.getErrorCode(),
+ ResponseCode.internalError.getErrorMessage(),
+ ResponseCode.SERVER_ERROR.getResponseCode());
+ }
+ Request request = new Request(requestContext);
+ telemetryInfo.put(JsonKey.TELEMETRY_EVENT_TYPE, TelemetryEvents.ERROR.getName());
+
+ Map params = (Map) telemetryInfo.get(JsonKey.PARAMS);
+ params.put(JsonKey.ERROR, projectCommonException.getCode());
+ params.put(JsonKey.STACKTRACE, generateStackTrace(e.getStackTrace()));
+ request.setRequest(telemetryInfo);
+ // lmaxWriter.submitMessage(request);
+ TelemetryWriter.write(request);
+ }
+
+ /**
+ * Generates a string representation of the stack trace.
+ *
+ * @param elements Stack trace elements.
+ * @return The stack trace as a string.
+ */
+ private String generateStackTrace(StackTraceElement[] elements) {
+ StringBuilder builder = new StringBuilder("");
+ for (StackTraceElement element : elements) {
+ builder.append(element.toString());
+ }
+ return builder.toString();
+ }
+
+ /**
+ * Converts log data into a JSON string using CustomLogFormat.
+ *
+ * @param requestContext The request context.
+ * @param message The log message.
+ * @param object Additional object data.
+ * @param param Additional parameters.
+ * @return JSON string of the log event.
+ */
+ private String jsonMapper(
+ RequestContext requestContext,
+ String message,
+ Map object,
+ Map param) {
+ try {
+ return mapper.writeValueAsString(
+ new CustomLogFormat(requestContext, message, object, param).getEventMap());
+ } catch (JsonProcessingException e) {
+ error(requestContext, e.getMessage(), e);
+ }
+ return "";
+ }
+}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectLogger.java b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/ProjectLogger.java
similarity index 72%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectLogger.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/logging/ProjectLogger.java
index c5026324b..e612d1308 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ProjectLogger.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/logging/ProjectLogger.java
@@ -1,28 +1,28 @@
-/** */
-package org.sunbird.common.models.util;
+package org.sunbird.logging;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
-
import net.logstash.logback.argument.StructuredArguments;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.sunbird.common.exception.ProjectCommonException;
-import org.sunbird.common.request.Request;
-import org.sunbird.common.request.RequestContext;
-import org.sunbird.common.responsecode.ResponseCode;
+import org.sunbird.request.Request;
+import org.sunbird.request.RequestContext;
+import org.sunbird.response.ResponseCode;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.keys.JsonKey;
import org.sunbird.telemetry.util.TelemetryEvents;
import org.sunbird.telemetry.util.TelemetryWriter;
/**
- * This class will used to log the project message in any level.
+ * Legacy logger class for project-level logging provided for backward compatibility.
*
- * @author Manzarul
+ * @deprecated Use {@link LoggerUtil} for all logging operations. This class will be removed in future versions.
*/
+@Deprecated
public class ProjectLogger {
private static String eVersion = "1.0";
@@ -31,24 +31,41 @@ public class ProjectLogger {
private static ObjectMapper mapper = new ObjectMapper();
private static Logger rootLogger = LoggerFactory.getLogger("defaultLogger");
private static Logger queryLogger = LoggerFactory.getLogger("queryLogger");
- // private static TelemetryLmaxWriter lmaxWriter = TelemetryLmaxWriter.getInstance();
- /** To log only message. */
+ private ProjectLogger() {}
+
+ /**
+ * Logs a message with default log level (DEBUG).
+ *
+ * @param message Text message to be logged.
+ */
public static void log(String message) {
log(message, null, LoggerEnum.DEBUG.name());
}
+ /**
+ * Logs an exception message.
+ *
+ * @param message The message.
+ * @param e The exception.
+ */
public static void log(String message, Throwable e) {
log(message, null, e);
}
+ /**
+ * Logs a message with exception and telemetry information.
+ *
+ * @param message The message.
+ * @param e The exception.
+ * @param telemetryInfo Telemetry data.
+ */
public static void log(String message, Throwable e, Map telemetryInfo) {
log(message, null, e);
telemetryProcess(telemetryInfo, e);
}
private static void telemetryProcess(Map telemetryInfo, Throwable e) {
-
ProjectCommonException projectCommonException = null;
if (e instanceof ProjectCommonException) {
projectCommonException = (ProjectCommonException) e;
@@ -67,8 +84,6 @@ private static void telemetryProcess(Map telemetryInfo, Throwabl
params.put(JsonKey.STACKTRACE, generateStackTrace(e.getStackTrace()));
request.setRequest(telemetryInfo);
TelemetryWriter.write(request);
- // lmaxWriter.submitMessage(request);
-
}
private static String generateStackTrace(StackTraceElement[] elements) {
@@ -83,22 +98,46 @@ public static void log(String message, String logLevel) {
log(message, null, logLevel);
}
- /** To log message, data in used defined log level. */
+ /**
+ * Logs a message with a specific LoggerEnum level.
+ *
+ * @param message The message.
+ * @param logEnum The log level.
+ */
public static void log(String message, LoggerEnum logEnum) {
info(message, null, logEnum);
}
- /** To log message, data in used defined log level. */
+ /**
+ * Logs message and data with a specific string log level.
+ *
+ * @param message The message.
+ * @param data The data object.
+ * @param logLevel The log level string.
+ */
public static void log(String message, Object data, String logLevel) {
backendLog(message, data, null, logLevel);
}
- /** To log exception with message and data. */
+ /**
+ * Logs message, data, and exception.
+ *
+ * @param message The message.
+ * @param data The data object.
+ * @param e The exception.
+ */
public static void log(String message, Object data, Throwable e) {
backendLog(message, data, e, LoggerEnum.ERROR.name());
}
- /** To log exception with message and data for user specific log level. */
+ /**
+ * Logs message, data, exception with a specific log level.
+ *
+ * @param message The message.
+ * @param data The data object.
+ * @param e The exception.
+ * @param logLevel The log level.
+ */
public static void log(String message, Object data, Throwable e, String logLevel) {
backendLog(message, data, e, logLevel);
}
@@ -125,7 +164,6 @@ private static void warn(String message, Object data, Throwable exception) {
private static void backendLog(String message, Object data, Throwable e, String logLevel) {
if (!StringUtils.isBlank(logLevel)) {
-
switch (logLevel) {
case "INFO":
info(message, data);
@@ -148,18 +186,15 @@ private static void backendLog(String message, Object data, Throwable e, String
private static String getBELogEvent(
String logLevel, String message, Object data, LoggerEnum logEnum) {
- String logData = getBELog(logLevel, message, data, null, logEnum);
- return logData;
+ return getBELog(logLevel, message, data, null, logEnum);
}
private static String getBELogEvent(String logLevel, String message, Object data) {
- String logData = getBELog(logLevel, message, data, null, null);
- return logData;
+ return getBELog(logLevel, message, data, null, null);
}
private static String getBELogEvent(String logLevel, String message, Object data, Throwable e) {
- String logData = getBELog(logLevel, message, data, e, null);
- return logData;
+ return getBELog(logLevel, message, data, e, null);
}
private static String getBELog(
@@ -167,7 +202,7 @@ private static String getBELog(
String mid = dataId + "." + System.currentTimeMillis() + "." + UUID.randomUUID();
long unixTime = System.currentTimeMillis();
LogEvent te = new LogEvent();
- Map eks = new HashMap();
+ Map eks = new HashMap<>();
eks.put(JsonKey.LEVEL, logLevel);
eks.put(JsonKey.MESSAGE, message);
@@ -191,20 +226,22 @@ private static String getBELog(
te.setEdata(eks);
jsonMessage = mapper.writeValueAsString(te);
} catch (Exception e) {
- ProjectLogger.log(e.getMessage(), e);
+ // Avoid recursive calls to ProjectLogger.log if exception happens here
+ rootLogger.error(e.getMessage(), e);
}
return jsonMessage;
}
public static void logQuery(String query, RequestContext requestContext) {
- if(isDebugEnabled(requestContext)) {
- queryLogger.debug(query, StructuredArguments.entries(requestContext.getContextMap()));
+ if (isDebugEnabled(requestContext)) {
+ queryLogger.debug(query, StructuredArguments.entries(requestContext.getContextMap()));
} else {
queryLogger.debug(query);
}
}
-
+
private static boolean isDebugEnabled(RequestContext requestContext) {
- return (null != requestContext && StringUtils.equalsIgnoreCase("true", requestContext.getDebugEnabled()));
+ return (null != requestContext
+ && StringUtils.equalsIgnoreCase("true", requestContext.getDebugEnabled()));
}
}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ActorOperations.java b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/ActorOperations.java
similarity index 94%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ActorOperations.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/ActorOperations.java
index 458c7e1f0..9541b393b 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/ActorOperations.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/ActorOperations.java
@@ -1,10 +1,8 @@
-package org.sunbird.common.models.util;
+package org.sunbird.operations.lms;
/**
- * This enum will contains different operation for a learner {addCourse, getCourse, update ,
- * getContent}
- *
- * @author Manzarul
+ * Enum containing various operations performed by actors in the LMS system.
+ * These operations cover courses, users, organisations, pages, and system settings.
*/
public enum ActorOperations {
ENROLL_COURSE("enrollCourse"),
@@ -177,21 +175,21 @@ public enum ActorOperations {
LIST_JOB_REQUEST("listJobRequest"),
UPDATE_ACTIVITY_AGGREGATES("updateActivityAggregates");
- private String value;
+ private final String value;
/**
- * constructor
+ * Constructor for ActorOperations.
*
- * @param value String
+ * @param value The string value associated with the operation.
*/
ActorOperations(String value) {
this.value = value;
}
/**
- * returns the enum value
+ * Retrieves the string value of the operation.
*
- * @return String
+ * @return The operation value string.
*/
public String getValue() {
return this.value;
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadActorOperation.java b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/BulkUploadActorOperation.java
similarity index 54%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadActorOperation.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/BulkUploadActorOperation.java
index 66cc045da..1b1699b0b 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/BulkUploadActorOperation.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/BulkUploadActorOperation.java
@@ -1,6 +1,9 @@
-package org.sunbird.common.models.util;
+package org.sunbird.operations.lms;
-/** Enum to represent bulk upload operations */
+/**
+ * Enum representing various bulk upload operations within the LMS.
+ * Includes operations for locations, organizations, and users.
+ */
public enum BulkUploadActorOperation {
LOCATION_BULK_UPLOAD("locationBulkUpload"),
LOCATION_BULK_UPLOAD_BACKGROUND_JOB("locationBulkUploadBackground"),
@@ -12,12 +15,22 @@ public enum BulkUploadActorOperation {
USER_BULK_UPLOAD_BACKGROUND_JOB("userBulkUploadBackground"),
USER_BULK_MIGRATION("userBulkMigration");
- private String value;
+ private final String value;
+ /**
+ * Constructor for BulkUploadActorOperation.
+ *
+ * @param value The string value associated with the operation.
+ */
BulkUploadActorOperation(String value) {
this.value = value;
}
+ /**
+ * Retrieves the string value of the operation.
+ *
+ * @return The operation value string.
+ */
public String getValue() {
return this.value;
}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LocationActorOperation.java b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/LocationActorOperation.java
similarity index 57%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LocationActorOperation.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/LocationActorOperation.java
index 224c89482..cd7f6097a 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/models/util/LocationActorOperation.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/operations/lms/LocationActorOperation.java
@@ -1,5 +1,8 @@
-package org.sunbird.common.models.util;
+package org.sunbird.operations.lms;
+/**
+ * Enum representing various operations related to locations within the system.
+ */
public enum LocationActorOperation {
CREATE_LOCATION("createLocation"),
UPDATE_LOCATION("updateLocation"),
@@ -10,12 +13,22 @@ public enum LocationActorOperation {
UPSERT_LOCATION_TO_ES("upsertLocationDataToES"),
DELETE_LOCATION_FROM_ES("deleteLocationDataFromES");
- private String value;
+ private final String value;
+ /**
+ * Constructor for LocationActorOperation.
+ *
+ * @param value The string value associated with the operation.
+ */
LocationActorOperation(String value) {
this.value = value;
}
+ /**
+ * Retrieves the string value of the operation.
+ *
+ * @return The operation value string.
+ */
public String getValue() {
return this.value;
}
diff --git a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/request/HeaderParam.java b/core/sunbird-platform-common/src/main/java/org/sunbird/request/HeaderParam.java
similarity index 50%
rename from course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/request/HeaderParam.java
rename to core/sunbird-platform-common/src/main/java/org/sunbird/request/HeaderParam.java
index 783632ab6..52cc5a97a 100644
--- a/course-mw/sunbird-util/sunbird-platform-core/common-util/src/main/java/org/sunbird/common/request/HeaderParam.java
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/request/HeaderParam.java
@@ -1,9 +1,8 @@
-package org.sunbird.common.request;
+package org.sunbird.request;
/**
- * The keys of the Execution Context Values.
- *
- * @author Manzarul
+ * Enum representing the keys for Execution Context Values and HTTP Headers.
+ * Used to maintain consistency across services for request/response headers.
*/
public enum HeaderParam {
REQUEST_ID,
@@ -25,45 +24,52 @@ public enum HeaderParam {
ts("ts"),
Content_Type("content-type"),
X_Authenticated_User_Token("x-authenticated-user-token"),
+ X_Authenticated_For("x-authenticated-for"),
X_Authenticated_Client_Token("x-authenticated-client-token"),
X_Authenticated_Client_Id("x-authenticated-client-id"),
X_APP_ID("x-app-id"),
CHANNEL_ID("x-channel-id"),
- X_Response_Length("x-response-length"),
- X_Authenticated_For("x-authenticated-for");
- /** name of the parameter */
+ X_Trace_ID("x-trace-id"),
+ X_REQUEST_ID("x-request-id"),
+ X_TRACE_ENABLED("x-trace-enabled"),
+ X_APP_VERSION("x-app-ver"),
+ X_APP_VERSION_PORTAL("x-app-version"),
+ X_SOURCE("x-source"),
+ X_Response_Length("x-response-length");
+
+ /** Name of the parameter/header. */
private String name;
/**
- * 1-arg constructor
+ * Constructor with name.
*
- * @param name String
+ * @param name The string representation of the header/parameter.
*/
private HeaderParam(String name) {
this.name = name;
}
/**
- * this will return parameter default name
+ * Default constructor.
+ */
+ private HeaderParam() {}
+
+ /**
+ * Returns the parameter name. If a specific name provided in constructor, returns that.
+ * Otherwise, returns the enum name.
*
- * @return
+ * @return The parameter name.
*/
public String getParamName() {
return this.name();
}
- private HeaderParam() {}
-
/**
- * This will provide name of one argument enum
+ * Returns the specific name associated with the enum constant, if any.
*
- * @return String
+ * @return The name value.
*/
public String getName() {
return name;
}
-
- public void setName(String name) {
- this.name = name;
- }
}
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/request/Request.java b/core/sunbird-platform-common/src/main/java/org/sunbird/request/Request.java
new file mode 100644
index 000000000..fa7c880b3
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/request/Request.java
@@ -0,0 +1,323 @@
+package org.sunbird.request;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.lang3.StringUtils;
+import org.sunbird.exception.ProjectCommonException;
+import org.sunbird.keys.JsonKey;
+import org.sunbird.common.ProjectUtil;
+import org.sunbird.response.ResponseCode;
+
+/**
+ * Consolidated Request class for Sunbird services (LMS, UserOrg, Notification).
+ *
+ *
This class standardizes the Request object across services, incorporating:
+ *
+ *
The rich feature set of the LMS implementation (utility methods).
+ *
The data safety of the Notification implementation (using HashMap instead of WeakHashMap).
+ *
Additional fields and constructors for flexibility.
+ *
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Request implements Serializable {
+
+ private static final long serialVersionUID = -2362783406031347676L;
+ private static final Integer MIN_TIMEOUT = 0;
+ private static final Integer MAX_TIMEOUT = 30;
+ private static final int WAIT_TIME_VALUE = 30;
+
+ protected Map context;
+ private RequestContext requestContext;
+
+ private String id;
+ private String ver;
+ private String ts;
+ private RequestParams params;
+
+ // Use HashMap instead of WeakHashMap to prevent premature garbage collection of request data
+ private Map request = new HashMap<>();
+
+ private String managerName;
+ private String operation;
+ private String requestId;
+ private int env;
+
+ // Path field from Notification service
+ protected String path;
+
+ private Integer timeout; // in seconds
+
+ /** Default constructor initializes context and params. */
+ public Request() {
+ this.context = new HashMap<>();
+ this.params = new RequestParams();
+ }
+
+ /**
+ * Constructor with RequestContext.
+ *
+ * @param requestContext The context of the request.
+ */
+ public Request(RequestContext requestContext) {
+ this.context = new HashMap<>();
+ this.params = new RequestParams();
+ this.requestContext = requestContext;
+ }
+
+ /**
+ * Copy constructor.
+ *
+ *
Note: This performs a shallow copy of RequestParams.
+ *
+ * @param request The request object to copy from.
+ */
+ public Request(Request request) {
+ this.params = request.getParams();
+ if (this.params == null) {
+ this.params = new RequestParams();
+ }
+ // Ensure msgid is set if available in the source request's params or requestId
+ if (StringUtils.isBlank(this.params.getMsgid())
+ && StringUtils.isNotBlank(request.getRequestId())) {
+ this.params.setMsgid(request.getRequestId());
+ }
+
+ this.context = new HashMap<>();
+ if (request.getContext() != null) {
+ this.context.putAll(request.getContext());
+ }
+
+ this.requestContext = request.getRequestContext();
+ this.request = new HashMap<>();
+ if (request.getRequest() != null) {
+ this.request.putAll(request.getRequest());
+ }
+
+ this.id = request.getId();
+ this.ver = request.getVer();
+ this.ts = request.getTs();
+ this.managerName = request.getManagerName();
+ this.operation = request.getOperation();
+ this.requestId = request.getRequestId();
+ this.env = request.getEnv();
+ this.path = request.getPath();
+ this.timeout = request.getTimeout();
+ }
+
+ /**
+ * Converts configured fields to lowercase in the request map. Configuration key: {@link
+ * JsonKey#SUNBIRD_API_REQUEST_LOWER_CASE_FIELDS}
+ */
+ public void toLower() {
+ String configValue = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_API_REQUEST_LOWER_CASE_FIELDS);
+ if (StringUtils.isNotBlank(configValue)) {
+ Arrays.stream(configValue.split(","))
+ .forEach(
+ field -> {
+ Object value = this.getRequest().get(field);
+ if (value instanceof String && StringUtils.isNotBlank((String) value)) {
+ this.getRequest().put(field, ((String) value).toLowerCase());
+ }
+ });
+ }
+ }
+
+ /**
+ * Gets the request ID. Checks params first, then the requestId field.
+ *
+ * @return The request ID.
+ */
+ public String getRequestId() {
+ // Logic from Notification: check params first
+ if (this.params != null && StringUtils.isNotBlank(this.params.getMsgid())) {
+ return this.params.getMsgid();
+ }
+ return requestId;
+ }
+
+ /**
+ * Sets the request ID.
+ *
+ * @param requestId The request ID to set.
+ */
+ public void setRequestId(String requestId) {
+ this.requestId = requestId;
+ // Sync with params if needed, or leave decoupled as per original implementations
+ }
+
+ public Map getContext() {
+ return context;
+ }
+
+ public void setContext(Map context) {
+ this.context = context;
+ }
+
+ public Map getRequest() {
+ return request;
+ }
+
+ public void setRequest(Map request) {
+ this.request = request;
+ }
+
+ public Object get(String key) {
+ return request.get(key);
+ }
+
+ /**
+ * Helper method to get a value with a default.
+ *
+ * @param key The key to look up.
+ * @param defaultVal The default value if key is not present.
+ * @return The value or the default.
+ */
+ public Object getOrDefault(String key, Object defaultVal) {
+ return request.getOrDefault(key, defaultVal);
+ }
+
+ /**
+ * Checks if the request map contains the key.
+ *
+ * @param key The key to check.
+ * @return True if key exists.
+ */
+ public Boolean contains(String key) {
+ return request.containsKey(key);
+ }
+
+ /**
+ * Puts a value into the request map.
+ *
+ * @param key The key.
+ * @param vo The value object.
+ */
+ public void put(String key, Object vo) {
+ request.put(key, vo);
+ }
+
+ /**
+ * Copies all entries from the given map to the request map.
+ *
+ * @param map The map to copy from.
+ */
+ public void copyRequestValueObjects(Map map) {
+ if (map != null && !map.isEmpty()) {
+ this.request.putAll(map);
+ }
+ }
+
+ public String getManagerName() {
+ return managerName;
+ }
+
+ public void setManagerName(String managerName) {
+ this.managerName = managerName;
+ }
+
+ public String getOperation() {
+ return operation;
+ }
+
+ public void setOperation(String operation) {
+ this.operation = operation;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getVer() {
+ return ver;
+ }
+
+ public void setVer(String ver) {
+ this.ver = ver;
+ }
+
+ public String getTs() {
+ return ts;
+ }
+
+ public void setTs(String ts) {
+ this.ts = ts;
+ }
+
+ public RequestParams getParams() {
+ return params;
+ }
+
+ /**
+ * Sets the request parameters. Auto-sets msgid if requestId is present.
+ *
+ * @param params The request parameters.
+ */
+ public void setParams(RequestParams params) {
+ this.params = params;
+ // Auto-set msgid if requestId is present and msgid is not
+ if (this.params.getMsgid() == null && requestId != null) {
+ this.params.setMsgid(requestId);
+ }
+ }
+
+ public int getEnv() {
+ return env;
+ }
+
+ public void setEnv(int env) {
+ this.env = env;
+ }
+
+ public Integer getTimeout() {
+ return timeout == null ? WAIT_TIME_VALUE : timeout;
+ }
+
+ /**
+ * Sets the timeout value.
+ *
+ * @param timeout The timeout in seconds.
+ * @throws ProjectCommonException If timeout is invalid.
+ */
+ public void setTimeout(Integer timeout) {
+ if (timeout < MIN_TIMEOUT && timeout > MAX_TIMEOUT) {
+ ProjectCommonException.throwServerErrorException(
+ ResponseCode.invalidRequestTimeout,
+ MessageFormat.format(ResponseCode.invalidRequestTimeout.getErrorMessage(), timeout));
+ }
+ this.timeout = timeout;
+ }
+
+ public RequestContext getRequestContext() {
+ return requestContext;
+ }
+
+ public void setRequestContext(RequestContext requestContext) {
+ this.requestContext = requestContext;
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public void setPath(String path) {
+ this.path = path;
+ }
+
+ @Override
+ public String toString() {
+ return "Request ["
+ + (context != null ? "context=" + context + ", " : "")
+ + (request != null ? "request=" + request + ", " : "")
+ + (id != null ? "id=" + id + ", " : "")
+ + (operation != null ? "operation=" + operation : "")
+ + "]";
+ }
+}
\ No newline at end of file
diff --git a/core/sunbird-platform-common/src/main/java/org/sunbird/request/RequestContext.java b/core/sunbird-platform-common/src/main/java/org/sunbird/request/RequestContext.java
new file mode 100644
index 000000000..ba5be88f8
--- /dev/null
+++ b/core/sunbird-platform-common/src/main/java/org/sunbird/request/RequestContext.java
@@ -0,0 +1,358 @@
+package org.sunbird.request;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Consolidated RequestContext class for Sunbird services (LMS, UserOrg, Notification).
+ *
+ *
This class serves as a unified context object that combines the fields and behaviors required by
+ * different services within the Sunbird platform. It supports:
+ *
+ *
+ *
LMS: Telemetry support with `pdata` (Protocol Data), `channel`, `env` (Environment),
+ * and a nested context map.
+ *
UserOrg: General request properties such as `appId`, `source`, and `telemetryContext`.
+ *
Notification: Actor and logging specific fields like `actorId` and `loggerLevel`.
+ *
+ *
+ *
This allows for a standardize way to pass request context information (headers, trace IDs,
+ * user info) through the service layers.
+ */
+public class RequestContext {
+
+ // -------------------------------------------------------------------------
+ // Common Fields
+ // -------------------------------------------------------------------------
+
+ /** User ID (Actor). */
+ private String uid;
+
+ /** Device ID. */
+ private String did;
+
+ /** Session ID. */
+ private String sid;
+
+ /** Debug mode flag. */
+ private String debugEnabled;
+
+ /**
+ * Request ID. Mapped to 'requestId' for LMS compatibility using JsonAlias.
+ */
+ @JsonProperty("reqId")
+ @JsonAlias("requestId")
+ private String reqId;
+
+ /** Operation name. */
+ private String op;
+
+ /**
+ * General context map to hold dynamic attributes.
+ * In LMS scenarios, this holds the telemetry context.
+ */
+ private Map contextMap = new HashMap<>();
+
+ // -------------------------------------------------------------------------
+ // UserOrg / Notification Specific Fields
+ // -------------------------------------------------------------------------
+
+ /** Application ID. */
+ private String appId;
+
+ /** Application Version. */
+ private String appVer;
+
+ /** Source of the request. */
+ private String source;
+
+ /** Specific telemetry context map for UserOrg/Notification services. */
+ private Map telemetryContext = new HashMap<>();
+
+ // -------------------------------------------------------------------------
+ // LMS Specific Fields
+ // -------------------------------------------------------------------------
+
+ /** Channel header value (X-Channel-Id). */
+ private String channel;
+
+ /** Environment identifier (e.g., "course", "user"). */
+ private String env;
+
+ /**
+ * Protocol Data (pdata) map.
+ * Contains 'id', 'pid', 'ver' for telemetry.
+ */
+ private Map pdata = new HashMap<>();
+
+ // -------------------------------------------------------------------------
+ // Notification / LMS Common Attributes
+ // -------------------------------------------------------------------------
+
+ /** ID of the actor performing the request. */
+ private String actorId;
+
+ /** Type of the actor (e.g., "Consumer", "System"). */
+ private String actorType;
+
+ /** Logging level for the request context. */
+ private String loggerLevel;
+
+ /**
+ * Default constructor.
+ */
+ public RequestContext() {}
+
+ /**
+ * Constructor designed for UserOrg and Notification style requests.
+ * Initializes general request metadata and populates the context map with these values.
+ *
+ * @param uid User ID
+ * @param did Device ID
+ * @param sid Session ID
+ * @param appId Application ID
+ * @param appVer Application Version
+ * @param reqId Request ID
+ * @param source Request Source
+ * @param debugEnabled Debug flag
+ * @param op Operation name
+ */
+ public RequestContext(
+ String uid,
+ String did,
+ String sid,
+ String appId,
+ String appVer,
+ String reqId,
+ String source,
+ String debugEnabled,
+ String op) {
+ this.uid = uid;
+ this.did = did;
+ this.sid = sid;
+ this.appId = appId;
+ this.appVer = appVer;
+ this.reqId = reqId;
+ this.source = source;
+ this.debugEnabled = debugEnabled;
+ this.op = op;
+
+ // Populate contextMap as done in UserOrg/Notification patterns
+ contextMap.put("uid", uid);
+ contextMap.put("did", did);
+ contextMap.put("sid", sid);
+ contextMap.put("appId", appId);
+ contextMap.put("appVer", appVer);
+ contextMap.put("reqId", reqId);
+ contextMap.put("source", source);
+ contextMap.put("op", op);
+ }
+
+ /**
+ * Constructor designed for LMS style requests, focusing on telemetry requirements.
+ * Initializes parameters required for constructing the `pdata` and telemetry `contextMap`.
+ *
+ * @param channel Channel ID
+ * @param pdataId Producer Data ID (e.g. producer ID)
+ * @param env Environment identifier
+ * @param did Device ID
+ * @param sid Session ID
+ * @param pid Producer ID
+ * @param pver Producer Version
+ * @param cdata Correlation Data list
+ */
+ public RequestContext(
+ String channel,
+ String pdataId,
+ String env,
+ String did,
+ String sid,
+ String pid,
+ String pver,
+ List