sdx-mailer-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 softdirex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "sdx-mailer-sdk",
+  "version": "1.0.0",
+  "description": "A api rest sdx-mailer-sender sdk",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softdirex/sdx-mailer-sdk.git"
+  },
+  "keywords": [
+    "typescript",
+    "npm",
+    "package"
+  ],
+  "author": "Softdirex",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.2.2"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/my-package/issues"
+  },
+  "homepage": "https://github.com/yourusername/my-package#readme",
+  "dependencies": {
+    "axios": "^1.5.1"
+  }
+}

package/src/CourierMail.ts

@@ -0,0 +1,50 @@
+import CourierExceptionRequest from "./entities/CourierExceptionRequest";
+import CourierLink from "./entities/CourierLink";
+import CourierRequest from "./entities/CourierRequest";
+import WebServiceException from "./entities/WebServiceException";
+import CourierService from "./services/CourierService";
+import Commons from "./utils/Commons";
+
+export default class CourierMail {
+
+    private service: CourierService;
+
+    constructor() {
+        this.service = new CourierService();
+    }
+
+    public createCourierRequest(title:string, subject:string,message:string,receiver:string,reply_mail:string,btn_label:string|null,btn_link:string|null):CourierRequest {
+        let request:CourierRequest = new CourierRequest();
+        request.title = title
+        request.subject = subject
+        request.message = message
+        request.receiver = receiver
+        request.reply_mail = reply_mail
+        if(btn_label != null || btn_link != null){
+            request.link = new CourierLink();
+            request.link.btn_label = btn_label
+            request.link.btn_link = btn_link
+        }
+        return request;
+    }
+
+    public createCourierExceptionRequest(error:string, detail:string,context:string|null):CourierExceptionRequest {
+        return new CourierExceptionRequest(error,detail,context);
+    }
+
+    public async sendCourierMail(endpoint:string,tokenRQ:any,productId:number,isBasic:boolean) {
+        const url = endpoint + '/courier' + ((isBasic)? '/basic' : '');
+        if(!Commons.validField(tokenRQ.trx)){
+            throw WebServiceException.BAD_REQUEST("Request must be signed")
+        }
+        return await this.service.postMail(null, tokenRQ, url, 'sendContactMail',productId);
+    }
+
+    public async sendExceptionMail(endpoint:string,tokenRQ:any,productId:number) {
+        const url = endpoint + '/courier';
+        if(!Commons.validField(tokenRQ.trx)){
+            throw WebServiceException.BAD_REQUEST("Request must be signed")
+        }
+        return await this.service.postMail(null, tokenRQ, url, 'sendContactMail',productId);
+    }
+}

package/src/entities/CourierExceptionRequest.ts

@@ -0,0 +1,13 @@
+
+export default class CourierExceptionRequest {
+
+     constructor(error:string,detail:string,context:string|null){
+          this.error = error
+          this.detail = detail
+          this.context = context
+     }
+
+     public error: string;
+     public detail: string|null;
+     public context: string|null;
+}

package/src/entities/CourierLink.ts

@@ -0,0 +1,4 @@
+export default class CourierLink {
+    public btn_label:string|null;
+    public btn_link:string|null;
+}

package/src/entities/CourierRequest.ts

@@ -0,0 +1,10 @@
+import CourierLink from "./CourierLink";
+
+export default class CourierRequest {
+    public subject: string;
+    public title: string;
+    public message:string;
+    public receiver:string;
+    public reply_mail:string;
+    public link:CourierLink|null;
+}

package/src/entities/ServiceResponse.ts

@@ -0,0 +1,40 @@
+
+export default class ServiceResponse {
+    public code: number
+    public message: string
+    public detail: string
+
+    constructor(code: number, message: string) {
+        this.code = code
+        this.message = message
+    }
+
+    public static BAD_REQUEST(): ServiceResponse {
+        var result = new ServiceResponse(400, "Bad Request")
+        return result;
+    }
+
+    public static BUSINESS_ERROR(): ServiceResponse {
+        return new ServiceResponse(500, "Business Error")
+    }
+
+    public static OK(): ServiceResponse {
+        return new ServiceResponse(200, "Ok")
+    }
+
+    public static UNAUTHORIZED(): ServiceResponse {
+        return new ServiceResponse(401, "Unauthorized")
+    }
+
+    public static NOT_FOUND(): ServiceResponse {
+        return new ServiceResponse(404, "Not Found")
+    }
+
+    public static SERVICE_UNAVAILABLE(): ServiceResponse {
+        return new ServiceResponse(503, "Service Unavailable")
+    }
+
+    public static METHOD_NOT_ALLOWED(): ServiceResponse {
+        return new ServiceResponse(405, "Method Not Allowed")
+    }
+}

package/src/entities/WebServiceException.ts

@@ -0,0 +1,47 @@
+import ServiceResponse from "./ServiceResponse";
+
+export default class WebServiceException {
+    public code: number;
+    public detail: string;
+    public message: string;
+    
+
+    constructor(message: string, code: number, detail: string) {
+        this.message = message;
+        this.code = code;
+        this.detail = detail;
+    }
+
+    public static BAD_REQUEST(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.BAD_REQUEST(), detail);
+    }
+
+    public static BUSINESS_ERROR(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.BUSINESS_ERROR(), detail);
+    }
+
+    public static OK(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.OK(), detail);
+    }
+
+    public static UNAUTHORIZED(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.UNAUTHORIZED(), detail);
+    }
+
+    public static NOT_FOUND(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.NOT_FOUND(), detail);
+    }
+
+    public static METHOD_NOT_ALLOWED(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.METHOD_NOT_ALLOWED(), detail);
+    }
+
+    public static SERVICE_UNAVAILABLE(detail: string): WebServiceException {
+        return this.buildStaticClass(ServiceResponse.SERVICE_UNAVAILABLE(), detail);
+    }
+
+    public static buildStaticClass(sr: ServiceResponse, detail: string): WebServiceException {
+        var result = new WebServiceException(sr.message, sr.code, detail)
+        return result;
+    }
+}

package/src/services/CourierService.ts

@@ -0,0 +1,28 @@
+import axios from 'axios';
+import Commons from '../utils/Commons';
+
+export default class CourierService {
+    public async postMail(basicAuth: string | null, body: any, url: string, methodName: string, productId: number) {
+        const res = await axios.post(url, body, this.buildOptions(basicAuth, true,productId)).catch(function (err) {
+            throw Commons.buildWebServiceException(err, 'POST', methodName);
+        });
+        return res.data;
+    }
+
+    private buildOptions(basicAuth: string | null, fullView: boolean, productId: number) {
+        if (basicAuth != null) {
+            return {
+                headers: {
+                    'Authorization': basicAuth,
+                    'product-id': productId,
+                    'view': (fullView) ? 'full' : 'basic'
+                }
+            }
+        }
+        return {
+            headers: {
+                'product-id': productId
+            }
+        }
+    }
+}

package/src/utils/Commons.ts

@@ -0,0 +1,41 @@
+import WebServiceException from '../entities/WebServiceException';
+import ServiceResponse from '../entities/ServiceResponse';
+
+export default class Commons {
+    /**
+     * This method throws an exception when the call service request fail
+     * @param err 
+     * @param verbMethod 
+     * @param methodName 
+     */
+    static buildWebServiceException(err: any, verbMethod: string, methodName: string): WebServiceException {
+        var ws: any = null
+        if (this.validField(err)
+            && this.validField(err.response)
+            && this.validField(err.response.data)
+            && this.validField(err.response.data.code)) {
+            ws = new ServiceResponse(err.response.data.code, err.response.data.message)
+            ws.detail = err.response.data.detail
+        }
+        if (ws != null) {
+            return WebServiceException.buildStaticClass(ws, this.buildDetailResponse(ws))
+        }
+        return WebServiceException.SERVICE_UNAVAILABLE('Error in ' + verbMethod + ' ' + methodName + ' service')
+    }
+
+     /**
+     * Detail builder for service response in throws, used by RequestServiceUtils
+     * @param ws 
+     * @returns 
+     */
+     static buildDetailResponse(ws: any): string {
+        if (Commons.validField(ws) && Commons.validField(ws.message)) {
+            return 'API_RESPONSE: ' + ((Commons.validField(ws.detail)) ? ws.detail : ws.message);
+        }
+        return 'API_RESPONSE: Without message'
+    }
+
+    static validField(arg: any) {
+        return arg != null && arg != undefined
+    }
+}