tradly 1.0.3 → 1.0.7

package/Constants/AppConstant.js

@@ -1,3 +1,7 @@
 
-export var BTOKEN = {token: ''};
+export var APPCONSTANT = {
+  TOKEN: '',
+  CURRENCY:'USD',
+};
 
+export const TYPES =  {account:'accounts', listing: 'listings', event: 'event'};

package/Constants/PathConstant.js

@@ -14,8 +14,44 @@ export const FORGOTPASSWORD = 'v1/users/password/recovery';
 export const USERS = 'v1/users';
 export const DEVICES = 'v1/devices';
 
+export const ADDRESS = '/v1/addresses'
+export const CURRENCY = 'v1/currencies';
+export const LANGUAGES = 'v1/languages';
+
+export const CATEGORY = 'v1/categories';
+export const ATTRIBUTE= 'v1/attributes';
+export const VALUES= '/values';
+
+export const ACCOUNTS = 'v1/accounts';
+export const FOLLOW = '/follow';
+export const BLOCK = '/block';
+export const REPORT = '/report';
+
+export const LISTINGS = 'products/v1/listings';
+export const LIKE  = '/likes';
+
+export const VARIANTTYPES = 'products/v1/variant_types';
+export const VARIANTS  = '/variants';
+
+export const PAYMENTSMETHODS = '/v1/tenants/payment_methods';
+export const SHIPPINGMETHOD = 'v1/tenants/shipping_methods';
+
+export const S3SIGNEDURL = 'v1/utils/S3signedUploadURL';
+export const SEARCHADDRESS = 'v1/addresses/search?key=';
 
 export const HOME = 'products/v1/home';
-export const CATEGORY = 'v1/categories?parent=0&type=';
-export const ATTRIBUTE= 'v1/attributes/?type=';
+export const ORDERS = 'products/v1/orders';
+
+export const CART = 'products/v1/cart';
+export const CHECKOUT = '/checkout';
+export const STATUS = '/status';
+export const REVIEW = '/v1/reviews';
+
+
+export const COLLECTIONS = '/v1/collections';
+export const PROMO = '/v1/promos';
+export const TRANSACTIONS = '/v1/transactions';
+export const EARNINGS = '/v1/earnings';
+
+
 

package/Helper/APIParam.js

@@ -0,0 +1,24 @@
+import { CONFIG, LOGIN } from "../Constants/PathConstant.js"
+
+export var APIS = {
+  config:'config',
+  login: 'login',
+}
+
+export function apiType(type = APIS) {
+  switch(type) {
+    case APIS.config:return CONFIG;
+    case APIS.login:return LOGIN;
+  }
+}
+export var UserParameter = {data:''}
+export var Parameter = {
+  bodyParam:'',
+  data:'',
+  id:'',
+  listingId:'',
+  auth:String,
+  isFollowing:Boolean,
+  isBlocked:Boolean,
+  isLiked:Boolean,
+}

package/Helper/Serialization.js

@@ -0,0 +1,9 @@
+
+function Serialization(param) {
+  var str = [];
+  for (var p in param)
+    str.push(encodeURIComponent(p) + "=" + encodeURIComponent(param[p]));
+  return str.join("&");
+
+}
+export default Serialization;

package/NetworkManager/NetworkManager.js

@@ -2,33 +2,65 @@
 
 import {to} from 'await-to-js';
 import axios from 'axios';
-import { BTOKEN } from '../Constants/AppConstant.js';
-import {BASEURL} from './../Constants/PathConstant.js'
+import { APPCONSTANT} from '../Constants/AppConstant.js';
+import {BASEURL} from '../Constants/PathConstant.js'
 
 var header = {
   'Accept': 'application/json',
   'Content-Type': 'application/json',
   'x-agent': 1,
 }
+export const Method = {
+  GET :'GET',
+  DELETE:'DELETE',
+  POST: 'POST',
+  PUT: 'PUT',
+  PATCH:'PATCH',
+}
+
+export var TradlyConfig = {
+  path:'',
+  method:Method,
+  param:'',
+  authKey:'',
+  refreshKey:'',
+}
+
 class NetworkManager {
-  networkCall = async (path,method, params,authkey, refreshKey) => {
+  networkCall = async (config = TradlyConfig) => {
     var BaseURL = BASEURL;
-    var url = BaseURL + path;
-    header['Authorization'] = "Bearer " + BTOKEN.token;
-    if (authkey != undefined) {
-      header['x-auth-key'] = authkey;
+    var url = BaseURL + config.path;
+    header['Authorization'] = "Bearer " + APPCONSTANT.TOKEN;
+    header['x-currency'] = APPCONSTANT.CURRENCY;
+    if (config.authKey != undefined || config.authKey == '') {
+      header['x-auth-key'] = config.authKey;
     }
-    if (refreshKey != undefined) {
-      header['X-Refresh-Key'] = refreshKey;
+    if (config.refreshKey != undefined || config.refreshKey == '') {
+      header['X-Refresh-Key'] = config.refreshKey;
     }
-    const [err,response] = await to(axios({url:url,method:method,responseType:'json',headers:header,data:params}))
+    console.log('header',header )
+    console.log('config',config )
+    console.log('param.param',config.param )
+
+    console.log('config.authkey',config.authKey )
+
+    const [err,response] = await to(axios({url:url,method:config.method,responseType:'json',headers:header,data:config.param}))
     if (err) {
-      let errData =  err['response']['data'];
+      let errData = err['response']['data'];
       return [errData, undefined];
     } else {
-        return [undefined, response['data']];
+      console.log('fddf ===> ',response['data']);
+      return [undefined, response['data']];
+    }
+  }
+  async uploadImage(signedUrl, mime, blob_body) {
+    const [err, response] = await to(axios({url:signedUrl,method:'put',headers:{'Content-Type': mime},data:blob_body}))
+    if (err) {
+      return false;
+    } else {
+      return true;
     }
   }
 }
 const network = new NetworkManager();
-export default network;
+export default network;

package/Roots/App.js

@@ -1,29 +1,483 @@
 
-import network from "./../NetworkManager/NetworkManager.js"
-import {ATTRIBUTE, CATEGORY, DEVICES, HOME, LOGIN, REGISTER,VERIFY} from './../Constants/PathConstant.js'
+import network, { Method } from "./../NetworkManager/NetworkManager.js"
+import {
+  ACCOUNTS, ATTRIBUTE,DEVICES, REPORT,
+  CATEGORY, CURRENCY, HOME,USERS, BLOCK,
+  LANGUAGES, LIKE, LISTINGS, ORDERS,REVIEW,
+  PAYMENTSMETHODS,ADDRESS, FOLLOW, COLLECTIONS, PROMO,
+  SHIPPINGMETHOD, VARIANTS,CART, CHECKOUT,
+  VALUES, TRANSACTIONS, EARNINGS, VARIANTTYPES, 
+} from './../Constants/PathConstant.js'
+import serialization from "../Helper/Serialization.js";
 
 class App {
-  async home() {
-    try {
-      const [error,responseJson] = await network.networkCall(HOME, 'GET');
-      if (error) { return error} 
-      else { return responseJson}
-    } catch (error) { return error}
+  async updateDeviceInfo(param = {data,authKey}) {
+    try { const [error,responseJson] = await network.networkCall({path:DEVICES,method:Method.POST,param:param.data,authKey:param.authKey});
+      if (error) { return error;
+      } else { return responseJson}
+    } catch (error) {return error}
   }
-  async getCategory(type) {
-    try {
-      const [error,responseJson] = await network.networkCall(CATEGORY + type, 'GET');
+  async updateUserInfo(param = {data,authKey}) {
+    try { const [error,responseJson] = await network.networkCall({path:USERS,method:Method.POST,param:param.data,authKey:param.authKey});
+      if (error) { return error;
+      } else { return responseJson}
+    } catch (error) {return error}
+  }
+  async home(param = {authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:HOME,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getLanguages(param = {authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:LANGUAGES,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  ADDRESS APIS  
+  async addEditAddress(param = {id,data,authKey}) {
+    let path = param.id == undefined || param.id == '' ? ADDRESS : ADDRESS + `/${param.id}`
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT;
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey})
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getAddress(param={bodyParam,authKey}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:ADDRESS + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteAddress(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:ADDRESS + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  ACCOUNTS APIS  
+  async getAccounts(param={bodyParam,authKey}) {
+    let url = `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:ACCOUNTS + `${url}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getAccountDetail(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:ACCOUNTS + `${param.id}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async postAccounts(param={id,authKey,data}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PATCH
+    let path = param.id == undefined || param.id == '' ? ACCOUNTS : ACCOUNTS + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async followUnfollowAccounts(param={id,authKey,isFollowing:Boolean}) {
+    let method = param.isFollowing ?  Method.DELETE : Method.POST
+    let path = ACCOUNTS + `/${param.id}` + FOLLOW
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async blockAccount(param={id,authKey,isBlocked:Boolean}) {
+    let method = param.isBlocked ? Method.DELETE : Method.POST
+    let path = ACCOUNTS + `/${param.id}` + BLOCK
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async blockAccount(param={id,authKey,data}) {
+    let method = Method.POST
+    let path = ACCOUNTS + `/${param.id}` + REPORT
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  LISTINGS API  
+  async getListings(param={bodyParam,authKey}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:LISTINGS + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getListingDetail(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:LISTINGS + `/${param.id}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteListing(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:LISTINGS + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async postListing(param={id,authKey,data}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PATCH
+    let path = param.id == undefined || param.id == '' ? LISTINGS : LISTINGS + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async likeListing(param={id,authKey,isLiked:Boolean}) {
+    let method = param.isLiked  ? Method.DELETE : Method.POST
+    let path = LISTINGS + `/${param.id}` + LIKE
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey});
       if (error) { return error }
       else { return responseJson }
-    } catch (error) { return error}
+    } catch (error) { return error }
   }
-  async getAttribute(type) {
-    try {
-      const [error,responseJson] = await network.networkCall(ATTRIBUTE + type, 'GET');
-      if (error) { return error}
+  async getVariants(param={authKey:''}) {
+    try { const [error, responseJson] = await network.networkCall({path:VARIANTS,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditVariants(param={authKey:'',listingId:'',id:'',data:{}}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    let path = param.id == undefined || param.id == '' ? LISTINGS + `/${param.listingId}/` + VARIANTS : LISTINGS + `/${param.listingId}/` + VARIANTS + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteVariant(param={id:'',listingId:'',authKey:''}) {
+    let url = LISTINGS + `/${param.listingId}/` + VARIANTS + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }  
+  //MARK:-  Variant Types  
+  async getVariantTypes(param={authKey:''}) {
+    try { const [error, responseJson] = await network.networkCall({path:VARIANTTYPES,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditVariantsTypes(param={authKey:'',id:'',data:{}}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    let path = param.id == undefined || param.id == '' ? VARIANTTYPES : VARIANTTYPES + `/${param.id}/`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteVariantType(param={id:'',authKey:''}) {
+    let url = VARIANTTYPES + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+    //MARK:-  Variant Types Values  
+  async getVariantTypeValues(param = {id:'',authKey:''}) {
+    let url =   VARIANTTYPES + `/${param.id}` + VALUES;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getVariantTypeValuesDetail(param = { id: '', valueID: '', authKey: '' }) {
+    let url =   VARIANTTYPES + `/${param.id}` + VALUES + `/${param.valueID}`;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditVariantTypeValues(param = { id: '', valueID: '', data: {}, authKey: '' }) {
+    let path = param.id == undefined || param.id == '' ? VARIANTTYPES + `/${param.id}` + VALUES : VARIANTTYPES + `/${param.id}` + VALUES + `/${param.valueID}` 
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT;
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteVariantTypeValues(param = { id: '', authKey: '', valueID: '' }) {
+    let url =   VARIANTTYPES + `/${param.id}` + VALUES + `/${param.valueID}`;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  CATEGORY APIS  
+  async getCategory(param = {bodyParam,authKey}) {
+    console.log('dsds', param.bodyParam);
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:CATEGORY + url, method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditCategory(param = {id:'',data:{},authKey:''}) {
+    let path = param.id == undefined || param.id == '' ? CATEGORY : CATEGORY + `/${param.id}`
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method, param:param.data, authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteCategory(param = {id:'',authKey:''}) {
+    try { const [error, responseJson] = await network.networkCall({path:CATEGORY + `/${param.id}`, method:Method.DELETE,authKey:param.authKey})
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Attribute APIS  
+
+  async getAttribute(param = {bodyParam:{},authKey:''}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:ATTRIBUTE + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditAttribute(param = {id:'',data:{},authKey:''}) {
+    let path = param.id == undefined || param.id == '' ? ATTRIBUTE : ATTRIBUTE + `/${param.id}`
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT;
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteAttribute(param = {id:'',authKey:''}) {
+    try { const [error, responseJson] = await network.networkCall({path:ATTRIBUTE + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Values
+  async getAttributeValues(param = {id:'',authKey:''}) {
+    let url =   ATTRIBUTE + `/${param.id}` + VALUES;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
       else { return responseJson }
-    } catch (error) { return error}
+    } catch (error) { return error }
+  }
+  async getAttributeValuesDetail(param = { id: '', valueID: '', authKey: '' }) {
+    let url =   ATTRIBUTE + `/${param.id}` + VALUES + `/${param.valueID}`;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditAttributeValues(param = { id: '', valueID: '', data: {}, authKey: '' }) {
+    let path = param.id == undefined || param.id == '' ? ATTRIBUTE + `/${param.id}` + VALUES : ATTRIBUTE + `/${param.id}` + VALUES + `/${param.valueID}` 
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT;
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteAttributeValues(param = { id: '', authKey: '', valueID: '' }) {
+    let url =   ATTRIBUTE + `/${param.id}` + VALUES + `/${param.valueID}`;
+    try { const [error, responseJson] = await network.networkCall({path:url,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  CART API  
+  async addToCart(param={authKey:'',data:{}}) {
+    try { const [error, responseJson] = await network.networkCall({path:CART,method:Method.POST,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteFromCart(param={authKey:'',data:{}}) {
+    try { const [error, responseJson] = await network.networkCall({path:CART,method:Method.PATCH,param:param.data,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getCarts(param={authKey:''}) {
+    try { const [error, responseJson] = await network.networkCall({path:CART,method:Method.GET,authKey:param.authKey});
+      if (error) { 
+        return error 
+      }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteAllCartDetail(param={authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:CART,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+
+  async checkout(param={authKey,data}) {
+    try { const [error, responseJson] = await network.networkCall({path:CART + CHECKOUT,method:Method.POST,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async listingDirectCheckout(param={authKey,data,id}) {
+    try { const [error, responseJson] = await network.networkCall({path:LISTINGS + `/${param.id}` + CHECKOUT,method:Method.POST,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  ORDERS API  
+  
+  async getOrders(param={authKey,bodyParam}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:ORDERS + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getOrderDetail(param={authKey,id}) {
+    try { const [error, responseJson] = await network.networkCall({path:ORDERS + `/${param.id}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async updateOrderStatus(param={authKey,id,data}) {
+    try { const [error, responseJson] = await network.networkCall({path:ORDERS + `/${param.id}` + STATUS,method:Method.PATCH,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async updateOrderDetail(param={authKey,id,data}) {
+    try { const [error, responseJson] = await network.networkCall({path:ORDERS + `/${param.id}`,method:Method.PATCH,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getReviewList(param={authKey,bodyParam}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:REVIEW + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addReview(param={authKey,data}) {
+    try { const [error, responseJson] = await network.networkCall({path:REVIEW,method:Method.POST,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async likeReview(param={authKey,data,id}) {
+    try { const [error, responseJson] = await network.networkCall({path:REVIEW + `/${param.id}` ,method:Method.PATCH,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getPaymentMethods(param={authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:PAYMENTSMETHODS ,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getShippingMethods(param={authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:SHIPPINGMETHOD ,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Currency 
+  async getCurrency(param={authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:CURRENCY,method:Method.GET,authKey:param.authKey})
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditCurrency(param={id,authKey,data}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    let path = param.id == undefined || param.id == '' ? CURRENCY : CURRENCY + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteCurrency(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:CURRENCY + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Collections 
+  async getCollection(param={authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:COLLECTIONS,method:Method.GET,authKey:param.authKey})
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getCollectionDetail(param={authKey,id}) {
+    try { const [error, responseJson] = await network.networkCall({path:COLLECTIONS + `/${param.id}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addEditCollection(param={id,authKey,data}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    let path = param.id == undefined || param.id == '' ? COLLECTIONS : COLLECTIONS + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deleteCollections(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:COLLECTIONS + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Promo banner 
+  async getPromoBanner(param={authKey,bodyParam}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:PROMO + url,method:Method.GET,authKey:param.authKey})
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getPromoBanner(param={authKey,id}) {
+    try { const [error, responseJson] = await network.networkCall({path:PROMO + `/${param.id}`,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async addPromoBanner(param={id,authKey,data}) {
+    let method = param.id == undefined || param.id == '' ? Method.POST : Method.PUT
+    let path = param.id == undefined || param.id == '' ? PROMO : PROMO + `/${param.id}`
+    try { const [error, responseJson] = await network.networkCall({path:path,method:method,authKey:param.authKey,param:param.data});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async deletePromoBanner(param={id,authKey}) {
+    try { const [error, responseJson] = await network.networkCall({path:PROMO + `/${param.id}`,method:Method.DELETE,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  //MARK:-  Transaction 
+  async getTransactions(param={authKey,bodyParam}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:TRANSACTIONS + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
+  }
+  async getEarning(param={authKey,bodyParam}) {
+    let url =  param.bodyParam == undefined || param.bodyParam == '' ? '' : `?${serialization(param.bodyParam)}`;
+    try { const [error, responseJson] = await network.networkCall({path:EARNINGS + url,method:Method.GET,authKey:param.authKey});
+      if (error) { return error }
+      else { return responseJson }
+    } catch (error) { return error }
   }
 }
 const app = new App();
-export default app;
+export default app;
+

package/Roots/Initialize.js

@@ -1,6 +1,6 @@
-import { BTOKEN } from "../Constants/AppConstant.js";
+import { APPCONSTANT } from "../Constants/AppConstant.js";
 import { CONFIG, TENANTS, REFRESH, HOME } from "../Constants/PathConstant.js";
-import network from "./../NetworkManager/NetworkManager.js"
+import network, { Method } from "./../NetworkManager/NetworkManager.js"
 import app from './App.js';
 
 
@@ -9,13 +9,13 @@ class InitializeSDK {
   async config(tenantKey) {
     let configs = TENANTS + tenantKey + CONFIG
     try {
-      const [error,responseJson] = await network.networkCall(configs, 'GET')
+      const [error,responseJson] = await network.networkCall({path:configs,method:Method.GET})
       if (error) {return error
       }else {
         let keyD = responseJson['data']['key'];
         if(keyD['app_key']) {
-          BTOKEN.token = keyD['app_key'];
-          console.log('Success!!')          
+          APPCONSTANT.TOKEN = keyD['app_key'];
+          console.log('Success!!')   
         }
         return responseJson;
       }
@@ -23,7 +23,7 @@ class InitializeSDK {
   }
   async refreshAPI(refreshKey) {
     try {
-      const [error,responseJson] = await network.networkCall(REFRESH, 'GET', undefined, undefined, refreshKey)
+      const [error,responseJson] = await network.networkCall({path:REFRESH,method:Method.GET,refreshKey:refreshKey})
       if (error) {
         return error;
       }else {

package/Roots/User.js

@@ -1,42 +1,32 @@
 
-import network from "./../NetworkManager/NetworkManager.js"
-import {DEVICES, LOGIN, REGISTER,VERIFY} from './../Constants/PathConstant.js'
+import network, { Method } from "./../NetworkManager/NetworkManager.js"
+import {LOGIN, REGISTER,VERIFY} from './../Constants/PathConstant.js'
+import { UserParameter } from "../Helper/APIParam.js";
 
 class User {
-  async login(params, authkey) {
-    try {
-      const [error,responseJson] = await network.networkCall(LOGIN, 'POST', params, authkey);
+  async login(param = UserParameter) {
+    try { const [error,responseJson] = await network.networkCall({path:LOGIN,method:Method.POST,param:param.data});
       if (error) { return error
       } else { return responseJson}
     } catch (error) { return error}
   }
-  async register(params, authkey) {
-    try {
-      const [error,responseJson] = await network.networkCall(REGISTER, 'POST', params, authkey);
+  async register(param = UserParameter) {
+    try { const [error,responseJson] = await network.networkCall({path:REGISTER,method:Method.POST,param:param.data});
       if (error) { return error} else { return responseJson }
     } catch (error) { return error }
   }
-  async verify(params, authkey) {
-    try {
-      const [error,responseJson] = await network.networkCall(VERIFY, 'POST', params, authkey);
+  async verify(param = UserParameter) {
+    try { const [error,responseJson] = await network.networkCall({path:VERIFY,method:Method.POST,param:param.data});
       if (error) {return error 
       } else { return responseJson }
     } catch (error) { return error}
   }
-  async resendOTP(params, authkey) {
-    try {
-      const [error,responseJson] = await network.networkCall(REGISTER, 'POST', params, authkey);
+  async resendOTP(param = UserParameter) {
+    try { const [error,responseJson] = await network.networkCall({path:REGISTER,method:Method.POST,param:param.data});
       if (error) { return error
       } else { return responseJson}
     } catch (error) { return error}
   }
-  async updateDeviceInfo(params, authkey) {
-    try {
-      const [error,responseJson] = await network.networkCall(DEVICES, 'POST', params, authkey);
-      if (error) { return error;
-      } else { return responseJson}
-    } catch (error) {return error}
-  }
 }
 const user = new User();
 export default user;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tradly",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "Tradly JS SDK",
   "main": "index.js",
   "type": "module",