Komodo / komodo-sdk-supplier-product-quota

Download as
Browse Code ยป

Commit 6a2e4bb6be38193806b301c36ca2e4186352c120

Authored by Adhidarma Hadiwinoto
1 parent 43852ed365
Exists in master

Dispose remaining + 1

Showing 1 changed file with 1 additions and 2 deletions Inline Diff

1 const MODULE_NAME = 'SDK-SUPPLIER-PRODUCT-QUOTA.REDIS-UTIL'; 1 const MODULE_NAME = 'SDK-SUPPLIER-PRODUCT-QUOTA.REDIS-UTIL';
2 const DEFAULT_TTL = 3600 * 24 * 90; 2 const DEFAULT_TTL = 3600 * 24 * 90;
3 const LIMITED_SET_NAME = 'SPQ_8FB2B6EC_MANAGED'; 3 const LIMITED_SET_NAME = 'SPQ_8FB2B6EC_MANAGED';
4 4
5 const redis = require('redis'); 5 const redis = require('redis');
6 const { orderBy } = require('natural-orderby'); 6 const { orderBy } = require('natural-orderby');
7 7
8 const config = require('komodo-sdk/config'); 8 const config = require('komodo-sdk/config');
9 const logger = require('komodo-sdk/logger'); 9 const logger = require('komodo-sdk/logger');
10 10
11 const redisClient = redis.createClient(); 11 const redisClient = redis.createClient();
12 12
13 const composeKeyword = (product) => `SPQ_F7D526DB_COUNTER_${config.handler_name}_${product.trim().toUpperCase()}`; 13 const composeKeyword = (product) => `SPQ_F7D526DB_COUNTER_${config.handler_name}_${product.trim().toUpperCase()}`;
14 14
15 const set = (product, val, xid) => new Promise((resolve) => { 15 const set = (product, val, xid) => new Promise((resolve) => {
16 if (!(product || '').trim()) { 16 if (!(product || '').trim()) {
17 resolve(); 17 resolve();
18 return; 18 return;
19 } 19 }
20 20
21 const keyword = composeKeyword(product); 21 const keyword = composeKeyword(product);
22 redisClient.set(keyword, Number(val), 'EX', DEFAULT_TTL, (err) => { 22 redisClient.set(keyword, Number(val), 'EX', DEFAULT_TTL, (err) => {
23 if (err) { 23 if (err) {
24 logger.warn(`F7D526DB ${MODULE_NAME}: Error on set value on redis`, { 24 logger.warn(`F7D526DB ${MODULE_NAME}: Error on set value on redis`, {
25 xid, product, val, eCode: err.code, eMessage: err.message, 25 xid, product, val, eCode: err.code, eMessage: err.message,
26 }); 26 });
27 resolve(); 27 resolve();
28 return; 28 return;
29 } 29 }
30 30
31 resolve(val); 31 resolve(val);
32 }); 32 });
33 }); 33 });
34 34
35 const get = (product, xid) => new Promise((resolve) => { 35 const get = (product, xid) => new Promise((resolve) => {
36 if (!(product || '').trim()) { 36 if (!(product || '').trim()) {
37 resolve(); 37 resolve();
38 return; 38 return;
39 } 39 }
40 40
41 const keyword = composeKeyword(product); 41 const keyword = composeKeyword(product);
42 42
43 redisClient.get(keyword, (err, reply) => { 43 redisClient.get(keyword, (err, reply) => {
44 if (err) { 44 if (err) {
45 logger.warn(`277CFDD4 ${MODULE_NAME}: Error on get value on redis`, { 45 logger.warn(`277CFDD4 ${MODULE_NAME}: Error on get value on redis`, {
46 xid, product, eCode: err.code, eMessage: err.message, 46 xid, product, eCode: err.code, eMessage: err.message,
47 }); 47 });
48 48
49 resolve(null); 49 resolve(null);
50 return; 50 return;
51 } 51 }
52 52
53 if (!reply) { 53 if (!reply) {
54 resolve(); 54 resolve();
55 return; 55 return;
56 } 56 }
57 57
58 resolve(Number(reply)); 58 resolve(Number(reply));
59 }); 59 });
60 }); 60 });
61 exports.get = get; 61 exports.get = get;
62 62
63 const isLimited = (product, xid) => new Promise((resolve) => { 63 const isLimited = (product, xid) => new Promise((resolve) => {
64 const supplier = config.handler_name; 64 const supplier = config.handler_name;
65 const val = JSON.stringify({ supplier, product }); 65 const val = JSON.stringify({ supplier, product });
66 66
67 redisClient.sismember(LIMITED_SET_NAME, val, (err, reply) => { 67 redisClient.sismember(LIMITED_SET_NAME, val, (err, reply) => {
68 if (err) { 68 if (err) {
69 logger.warn(`20D042AC ${MODULE_NAME}: Error on checking if on managed set`, { 69 logger.warn(`20D042AC ${MODULE_NAME}: Error on checking if on managed set`, {
70 xid, product, eCode: err.code, eMessage: err.message, 70 xid, product, eCode: err.code, eMessage: err.message,
71 }); 71 });
72 72
73 resolve(null); 73 resolve(null);
74 return; 74 return;
75 } 75 }
76 76
77 resolve(!!reply); 77 resolve(!!reply);
78 }); 78 });
79 }); 79 });
80 exports.isLimited = isLimited; 80 exports.isLimited = isLimited;
81 81
82 const addToLimited = (product, xid) => new Promise((resolve) => { 82 const addToLimited = (product, xid) => new Promise((resolve) => {
83 if (!(product || '').trim()) { 83 if (!(product || '').trim()) {
84 resolve(); 84 resolve();
85 return; 85 return;
86 } 86 }
87 87
88 const supplier = config.handler_name; 88 const supplier = config.handler_name;
89 const val = JSON.stringify({ supplier, product: product.trim().toUpperCase() }); 89 const val = JSON.stringify({ supplier, product: product.trim().toUpperCase() });
90 90
91 redisClient.sadd(LIMITED_SET_NAME, val, (err, reply) => { 91 redisClient.sadd(LIMITED_SET_NAME, val, (err, reply) => {
92 if (err) { 92 if (err) {
93 logger.warn(`E5AA0994 ${MODULE_NAME}: Error on add to managed set`, { 93 logger.warn(`E5AA0994 ${MODULE_NAME}: Error on add to managed set`, {
94 xid, product, eCode: err.code, eMessage: err.message, 94 xid, product, eCode: err.code, eMessage: err.message,
95 }); 95 });
96 96
97 resolve(); 97 resolve();
98 return; 98 return;
99 } 99 }
100 100
101 resolve(reply); 101 resolve(reply);
102 }); 102 });
103 }); 103 });
104 exports.addToLimited = addToLimited; 104 exports.addToLimited = addToLimited;
105 105
106 const removeFromLimited = (product, xid) => new Promise((resolve) => { 106 const removeFromLimited = (product, xid) => new Promise((resolve) => {
107 const supplier = config.handler_name; 107 const supplier = config.handler_name;
108 const val = JSON.stringify({ supplier, product }); 108 const val = JSON.stringify({ supplier, product });
109 109
110 redisClient.srem(LIMITED_SET_NAME, val, (err, reply) => { 110 redisClient.srem(LIMITED_SET_NAME, val, (err, reply) => {
111 if (err) { 111 if (err) {
112 logger.warn(`DD5CBDF2 ${MODULE_NAME}: Error on remove from managed set`, { 112 logger.warn(`DD5CBDF2 ${MODULE_NAME}: Error on remove from managed set`, {
113 xid, product, eCode: err.code, eMessage: err.message, 113 xid, product, eCode: err.code, eMessage: err.message,
114 }); 114 });
115 115
116 resolve(); 116 resolve();
117 return; 117 return;
118 } 118 }
119 119
120 resolve(reply); 120 resolve(reply);
121 }); 121 });
122 }); 122 });
123 exports.removeFromLimited = removeFromLimited; 123 exports.removeFromLimited = removeFromLimited;
124 124
125 const setLimit = async (product, newValue, xid) => { 125 const setLimit = async (product, newValue, xid) => {
126 await addToLimited(product, xid); 126 await addToLimited(product, xid);
127 await set(product, Number(newValue)); 127 await set(product, Number(newValue));
128 }; 128 };
129 exports.setLimit = setLimit; 129 exports.setLimit = setLimit;
130 130
131 const decrement = (product, xid) => new Promise((resolve) => { 131 const decrement = (product, xid) => new Promise((resolve) => {
132 const keyword = composeKeyword(product); 132 const keyword = composeKeyword(product);
133 133
134 redisClient.decr(keyword, (err, reply) => { 134 redisClient.decr(keyword, (err, reply) => {
135 if (err) { 135 if (err) {
136 logger.warn(`BA176849 ${MODULE_NAME}: Error on decrementing value`, { 136 logger.warn(`BA176849 ${MODULE_NAME}: Error on decrementing value`, {
137 xid, product, eCode: err.code, eMessage: err.message, 137 xid, product, eCode: err.code, eMessage: err.message,
138 }); 138 });
139 139
140 resolve(null); 140 resolve(null);
141 return; 141 return;
142 } 142 }
143 143
144 redisClient.expire(keyword, DEFAULT_TTL); 144 redisClient.expire(keyword, DEFAULT_TTL);
145 145
146 resolve(reply); 146 resolve(reply);
147 }); 147 });
148 }); 148 });
149 exports.decrement = decrement;
150 149
151 const increment = (product, xid) => new Promise((resolve) => { 150 const increment = (product, xid) => new Promise((resolve) => {
152 const keyword = composeKeyword(product); 151 const keyword = composeKeyword(product);
153 152
154 redisClient.incr(keyword, (err, reply) => { 153 redisClient.incr(keyword, (err, reply) => {
155 if (err) { 154 if (err) {
156 logger.warn(`8DA99C28 ${MODULE_NAME}: Error on incrementing`, { 155 logger.warn(`8DA99C28 ${MODULE_NAME}: Error on incrementing`, {
157 xid, product, eCode: err.code, eMessage: err.message, 156 xid, product, eCode: err.code, eMessage: err.message,
158 }); 157 });
159 158
160 redisClient.expire(keyword, DEFAULT_TTL); 159 redisClient.expire(keyword, DEFAULT_TTL);
161 160
162 resolve(null); 161 resolve(null);
163 return; 162 return;
164 } 163 }
165 164
166 resolve(reply); 165 resolve(reply);
167 }); 166 });
168 }); 167 });
169 168
170 const incrementBy = (product, val, xid) => new Promise((resolve) => { 169 const incrementBy = (product, val, xid) => new Promise((resolve) => {
171 const keyword = composeKeyword(product); 170 const keyword = composeKeyword(product);
172 171
173 redisClient.incrby(keyword, Math.trunc(Number(val)), (err, reply) => { 172 redisClient.incrby(keyword, Math.trunc(Number(val)), (err, reply) => {
174 if (err) { 173 if (err) {
175 logger.warn(`83038699 ${MODULE_NAME}: Error on incrementing by`, { 174 logger.warn(`83038699 ${MODULE_NAME}: Error on incrementing by`, {
176 xid, product, eCode: err.code, eMessage: err.message, 175 xid, product, eCode: err.code, eMessage: err.message,
177 }); 176 });
178 177
179 redisClient.expire(keyword, DEFAULT_TTL); 178 redisClient.expire(keyword, DEFAULT_TTL);
180 179
181 resolve(null); 180 resolve(null);
182 return; 181 return;
183 } 182 }
184 183
185 resolve(reply); 184 resolve(reply);
186 }); 185 });
187 }); 186 });
188 exports.incrementBy = incrementBy; 187 exports.incrementBy = incrementBy;
189 188
190 const dispose = async (product, xid) => { 189 const dispose = async (product, xid) => {
191 if (!await isLimited(product, xid)) { 190 if (!await isLimited(product, xid)) {
192 return true; 191 return true;
193 } 192 }
194 193
195 const remaining = await decrement(product, xid); 194 const remaining = await decrement(product, xid);
196 if (!remaining && remaining !== 0) { 195 if (!remaining && remaining !== 0) {
197 return true; 196 return true;
198 } 197 }
199 198
200 if (remaining < 0) { 199 if (remaining < 0) {
201 await set(product, 0, xid); 200 await set(product, 0, xid);
202 return 0; 201 return 0;
203 } 202 }
204 203
205 return remaining; 204 return remaining + 1;
206 }; 205 };
207 exports.dispose = dispose; 206 exports.dispose = dispose;
208 207
209 const putBack = async (product, xid) => { 208 const putBack = async (product, xid) => {
210 if (!await isLimited(product, xid)) { 209 if (!await isLimited(product, xid)) {
211 return; 210 return;
212 } 211 }
213 212
214 await increment(product, xid); 213 await increment(product, xid);
215 }; 214 };
216 exports.putBack = putBack; 215 exports.putBack = putBack;
217 216
218 const limitedList = (xid) => new Promise((resolve, reject) => { 217 const limitedList = (xid) => new Promise((resolve, reject) => {
219 redisClient.smembers(LIMITED_SET_NAME, (err, reply) => { 218 redisClient.smembers(LIMITED_SET_NAME, (err, reply) => {
220 if (err) { 219 if (err) {
221 const newError = new Error('Error getting limited list'); 220 const newError = new Error('Error getting limited list');
222 newError.code = 'BA176849'; 221 newError.code = 'BA176849';
223 logger.warn(`BA176849 ${MODULE_NAME}: ${newError.message}`, { 222 logger.warn(`BA176849 ${MODULE_NAME}: ${newError.message}`, {
224 xid, eCode: err.code, eMessage: err.message, newErrCode: newError.code, 223 xid, eCode: err.code, eMessage: err.message, newErrCode: newError.code,
225 }); 224 });
226 225
227 reject(newError); 226 reject(newError);
228 return; 227 return;
229 } 228 }
230 229
231 const result = (reply || []) 230 const result = (reply || [])
232 .map((item) => JSON.parse(item)); 231 .map((item) => JSON.parse(item));
233 232
234 resolve( 233 resolve(
235 orderBy( 234 orderBy(
236 result, 235 result,
237 [(item) => item.supplier, (item) => item.product], 236 [(item) => item.supplier, (item) => item.product],
238 ['asc', 'asc'], 237 ['asc', 'asc'],
239 ), 238 ),
240 ); 239 );
241 }); 240 });
242 }); 241 });
243 exports.limitedList = limitedList; 242 exports.limitedList = limitedList;
244 243