docs updated

Author: ishaileshmishra

README.md

@@ -24,27 +24,27 @@ You need Java 8 or above installed on your machine to use the Contentstack Manag
 
 ### Installation
 
-Install it via maven:
+**Install it via maven:**
 
 ```java
 <dependency>
-<groupId>com.contentstack.sdk</groupId>
-<artifactId>cms</artifactId>
-<version>{version}</version>
+   <groupId>com.contentstack.sdk</groupId>
+   <artifactId>cms</artifactId>
+   <version>{version}</version>
 </dependency>
 ```
 
-Install it via gradle:
+**Install it via gradle:**
 
 ```java
-   implementation'com.contentstack.sdk:cms:{version}'
+implementation'com.contentstack.sdk:cms:{version}'
 ```
 
 To import the SDK, use the following command:
 
 ```java
-    package com.contentstack.cms;
-    Contentstack contentstack=new Contentstack.Builder().build();
+package com.contentstack.cms;
+Contentstack contentstack = new Contentstack.Builder().build();
 ```
 
 ### Authentication
@@ -58,16 +58,16 @@ An [Authtoken](https://www.contentstack.com/docs/developers/create-tokens/types-
 is a read-write token used to make authorized CMA requests, and it is a **user-specific** token.
 
 ```java
-        Contentstack contentstack=new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
+Contentstack contentstack = new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
 ```
 
 ### Login
 
 To Login to Contentstack by using credentials, you can use the following lines of code:
 
 ```java
-        Contentstack contentstack=new Contentstack.Builder().build();
-        contentstack.login("EMAIL","PASSWORD");
+Contentstack contentstack = new Contentstack.Builder().build();
+contentstack.login("EMAIL","PASSWORD");
 ```
 
 ### Management Token
@@ -76,8 +76,8 @@ To Login to Contentstack by using credentials, you can use the following lines o
 *stack-level** tokens, with no users attached to them.
 
 ```java
-        Contentstack contentstack=new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
-        Stack stack=contentstack.stack("API_KEY","MANAGEMENT_TOKEN");
+Contentstack contentstack = new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
+Stack stack=contentstack.stack("API_KEY","MANAGEMENT_TOKEN");
 ```
 
 ### Contentstack Management Java SDK: 5-minute Quickstart
@@ -87,52 +87,52 @@ To Login to Contentstack by using credentials, you can use the following lines o
 To use the Java CMA SDK, you need to first initialize it. To do this, use the following code:
 
 ```java
-   Contentstack contentstack=new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
+Contentstack contentstack = new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
 ```
 
 #### Fetch Stack Detail
 
 Use the following lines of code to fetch your stack detail using this SDK:
 
 ```java
-        Stack stack=contentstack.stack("API_KEY");
-        Response<ResponseBody> response=stack.fetch().execute();
+Stack stack = contentstack.stack("API_KEY");
+Response<ResponseBody> response = stack.fetch().execute();
 ```
 
 #### Create Entry
 
 To create an entry in a specific content type of a stack, use the following lines of code:
 
 ```java
-        Contentstack contentstack=new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
-        Stack stack=contentstack.stack("API_KEY");
-        JSONObject body=....
-        Response<ResponseBody> response=entry.create(body).execute();
-        if(response.isSuccessful()){
-        System.out.println(response.body());
-        }
+Contentstack contentstack = new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
+Stack stack=contentstack.stack("API_KEY");
+JSONObject body = ....
+Response<ResponseBody> response=entry.create(body).execute();
+if(response.isSuccessful()){
+   System.out.println(response.body());
+}
 ```
 
 #### Create Asset
 
 The following lines of code can be used to upload assets to your stack:
 
 ```java
-        Contentstack contentstack=new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
-        Stack stack=contentstack.stack("API_KEY");
-        Asset asset=stack.asset();
-        Response<ResponseBody> response=asset.uploadAsset("filePath","description").execute();
-        if(response.isSuccessful()){
-        System.out.println(response.body());
-        }else{
-        System.out.println(response.errorBody());
-        }
+Contentstack contentstack = new Contentstack.Builder().setAuthtoken("AUTHTOKEN").build();
+Stack stack=contentstack.stack("API_KEY");
+Asset asset=stack.asset();
+Response<ResponseBody> response=asset.uploadAsset("filePath","description").execute();
+if(response.isSuccessful()){
+   System.out.println(response.body());
+}else{
+   System.out.println(response.errorBody());
+}
 ```
 
 ### Helpful Links
 
 - [Contentstack Website](https://www.contentstack.com/)
-- [Official Documentation](https://contentstack.com/docs)
+- [API Reference Documentation](https://www.contentstack.com/docs/developers/sdks/content-management-sdk/java)
 - [Content Management API Docs](https://www.contentstack.com/docs/developers/apis/content-management-api)
 
 ### The MIT License (MIT)

changelog.md

@@ -2,19 +2,16 @@
 
 ## v1.0.0
 
-### 30-June-2023
-
+### Jul 12, 2023
 - Bug Fixed For Unlocalize An Entry
 - Fixed Timeout Issue
-- General improvements with minor breaking changes
 - Code coverage improvements
 - NRP support added
-- 
+- General improvements with minor breaking changes
 
 ## v0.1.0
 
 ### Initial Release
 
-### 20-OCT-2022
-
+### Oct 20, 2022
 Initial release for Contentstack CMA base Java management SDK

pom.xml

@@ -60,7 +60,7 @@
         </developer>
     </developers>
 
-    <distributionManagement>
+    <!-- <distributionManagement>
         <snapshotRepository>
             <id>ossrh</id>
             <url>https://oss.sonatype.org/content/repositories/snapshots</url>
@@ -69,7 +69,7 @@
             <id>ossrh</id>
             <url>https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/</url>
         </repository>
-    </distributionManagement>
+    </distributionManagement> -->
 
     <properties>
         <sdk.version>0.1.0-SNAPSHOT</sdk.version>

src/main/java/com/contentstack/cms/core/AuthInterceptor.java

@@ -24,19 +24,46 @@
  */
 public class AuthInterceptor implements Interceptor {
 
+    protected String authtoken;
+
+    // The `public AuthInterceptor() {}` is a default constructor for the
+    // `AuthInterceptor` class. It is
+    // used to create an instance of the `AuthInterceptor` class without passing any
+    // arguments. In this
+    // case, it initializes the `authtoken` variable to `null`.
     public AuthInterceptor() {
     }
 
-    protected String authtoken;
-
+    // The `public AuthInterceptor(String authtoken)` is a constructor for the
+    // `AuthInterceptor` class that
+    // takes an `authtoken` parameter.
     public AuthInterceptor(String authtoken) {
         this.authtoken = authtoken;
     }
 
+    /**
+     * The function sets the value of the authtoken variable.
+     * 
+     * @param authtoken The authtoken parameter is a string that represents an
+     *                  authentication token.
+     */
     public void setAuthtoken(String authtoken) {
         this.authtoken = authtoken;
     }
 
+    /**
+     * This function intercepts a request and adds headers to it, including a user
+     * agent, content type, and
+     * authentication token if available.
+     * 
+     * @param chain The `chain` parameter is an object of type `Interceptor.Chain`.
+     *              It represents the chain
+     *              of interceptors that will be executed for a given request. It
+     *              provides methods to proceed to the
+     *              next interceptor in the chain or to proceed with the request and
+     *              get the response.
+     * @return The method is returning a Response object.
+     */
     @NotNull
     @Override
     public Response intercept(Chain chain) throws IOException {

src/main/java/com/contentstack/cms/core/BadArgumentException.java

@@ -14,6 +14,13 @@ public BadArgumentException() {
         super();
     }
 
+    // The code `public BadArgumentException(String message) { super(message); }` is
+    // a constructor for the
+    // `BadArgumentException` class. It takes a `String` parameter `message` and
+    // calls the constructor of
+    // the superclass `IllegalArgumentException` with the `message` parameter. This
+    // allows you to create an
+    // instance of `BadArgumentException` with a custom error message.
     public BadArgumentException(String message) {
         super(message);
     }

src/main/java/com/contentstack/cms/core/CMALogger.java

@@ -15,30 +15,78 @@ public class CMALogger {
 
     private final Logger logger;
 
+    /**
+     * The function returns the logger object.
+     * 
+     * @return The method is returning an instance of the Logger class.
+     */
     public Logger getLogger() {
         return logger;
     }
 
+    // The `CMALogger` constructor is used to create an instance of the `CMALogger`
+    // class. It takes a
+    // parameter `className` of type `Class<?>` (any class) and initializes the
+    // `logger` object using the
+    // `getLogger` method of the `Logger` class. The `getLogger` method takes the
+    // simple name of the
+    // `className` and returns an instance of the `Logger` class. The `@NotNull`
+    // annotation indicates that
+    // the `className` parameter cannot be null.
     public CMALogger(@NotNull Class<?> className) {
         logger = Logger.getLogger(className.getSimpleName());
     }
 
+    // The `info` method in the `CMALogger` class is used to log a message at an
+    // informational level of
+    // detail using the logger. It takes a `String` parameter named `message` and
+    // logs the message using
+    // the `info` method of the logger.
+    // The `info` method in the `CMALogger` class is used to log a message at an
+    // informational level of
+    // detail using the logger. It takes a `String` parameter named `message` and
+    // logs the message
+    // using the `info` method of the logger. The `@NotNull` annotation indicates
+    // that the `message`
+    // parameter cannot be null.
     public void info(@NotNull String message) {
         logger.info(message);
     }
 
+    // The `fine` method in the `CMALogger` class is used to log a message at a fine
+    // level of detail using
+    // the logger. It takes a `String` parameter named `message` and logs the
+    // message using the `info`
+    // method of the logger.
     public void fine(@NotNull String message) {
         logger.info(message);
     }
 
+    // The `finer` method in the `CMALogger` class is used to log a message at a
+    // finer level of detail
+    // using the logger. It takes a `String` parameter named `message` and logs the
+    // message using the
+    // `finer` method of the logger.
     public void finer(@NotNull String message) {
         logger.finer(message);
     }
 
+    /**
+     * The function "warning" logs a warning message using a logger.
+     * 
+     * @param message A string parameter named "message" which is annotated with the
+     *                "@NotNull" annotation.
+     */
     public void warning(@NotNull String message) {
         logger.warning(message);
     }
 
+    /**
+     * The function "severe" logs a severe-level message using a logger.
+     * 
+     * @param message A string parameter named "message" which is annotated with the
+     *                "@NotNull" annotation.
+     */
     public void severe(@NotNull String message) {
         logger.severe(message);
     }