forked from
tokono.ma/diffuse
A music player that connects to your cloud/distributed storage.
Authentication housekeeping
+116
-121
+1
src/App/Authentication/State.elm
+1
src/App/Authentication/State.elm
+6
src/Js/Workers/Authentication/blockstack.js
+6
src/Js/Workers/Authentication/blockstack.js
+1
-1
src/Js/Workers/Authentication/local.js
+1
-1
src/Js/Workers/Authentication/local.js
+5
-7
src/Js/Workers/Authentication/remoteStorage.js
+5
-7
src/Js/Workers/Authentication/remoteStorage.js
···
2
2
3
3
4
4
const KEY = "isotach";
5
-
const rs = new RemoteStorage({ cache: false });
6
5
7
6
8
-
rs.access.claim(KEY, "rw");
9
-
10
-
11
-
const client = rs.scope(`/${KEY}/`);
7
+
//
8
+
// Construct
12
9
10
+
const rs = new RemoteStorage({ cache: false });
11
+
const client = rs.scope(`/${KEY}/`);
13
12
13
+
rs.access.claim(KEY, "rw");
14
14
self.postMessage({ action: "CONSTRUCT_SUCCESS" });
15
15
16
16
···
22
22
if (!rs.remote.connected) {
23
23
rs.on("connected", () => tackle(event));
24
24
rs.connect(event.data.data.userAddress, event.data.data.token);
25
-
26
25
} else {
27
26
tackle(event);
28
-
29
27
}
30
28
};
31
29
+103
-113
src/Js/authentication.js
+103
-113
src/Js/authentication.js
···
49
49
}
50
50
51
51
52
-
function promised(fn) {
53
-
return () => new Promise(fn);
54
-
}
55
-
56
-
57
-
function resolved(fn) {
58
-
return () => Promise.resolve(fn.call(this));
59
-
}
60
-
61
-
62
52
63
53
//
64
54
// > Method
···
86
76
87
77
AUTH_SYSTEM.LOCAL = {
88
78
89
-
construct: () => (
90
-
construct("local").then(w => worker = w)
91
-
),
79
+
construct() {
80
+
return construct("local").then(w => worker = w);
81
+
},
82
+
92
83
93
-
deconstruct: resolved(() => {
84
+
deconstruct() {
94
85
worker.terminate();
95
86
worker = null;
96
-
}),
87
+
88
+
return Promise.resolve();
89
+
},
90
+
97
91
98
92
// In & Out
99
93
100
-
isSignedIn: resolved(
101
-
() => !!localStorage.getItem(ID)
102
-
),
103
94
104
-
isSigningIn: resolved(
105
-
() => false
106
-
),
95
+
isSignedIn:
96
+
() => Promise.resolve(!!localStorage.getItem(ID)),
97
+
107
98
108
-
handleSignInProcess: resolved(() => {
109
-
return "KeepUrl";
110
-
}),
99
+
isSigningIn:
100
+
() => Promise.resolve(false),
101
+
102
+
103
+
handleSignInProcess:
104
+
() => Promise.resolve("KeepUrl"),
105
+
111
106
112
-
signIn: resolved(() => {
107
+
signIn() {
113
108
localStorage.setItem(ID, "t");
114
-
return "None";
115
-
}),
109
+
return Promise.resolve("None");
110
+
},
111
+
116
112
117
-
signOut: resolved(() => {
113
+
signOut() {
118
114
localStorage.removeItem(ID);
119
-
}),
115
+
return Promise.resolve();
116
+
},
117
+
118
+
119
+
// Data
120
120
121
-
// Get data
122
121
123
-
getData: promised((resolve, reject) => {
122
+
getData: _ => new Promise((resolve, reject) => {
124
123
const handler = event => {
125
124
switch (event.data.action) {
126
125
case "GET_SUCCESS": return event.data.data
···
141
140
});
142
141
}),
143
142
144
-
// Store data
145
143
146
144
storeData: json => new Promise((resolve, reject) => {
147
145
const handler = event => {
···
178
176
179
177
AUTH_SYSTEM.BLOCKSTACK = {
180
178
181
-
construct: () => (
182
-
construct("blockstack").then(w => worker = w)
183
-
),
179
+
construct() {
180
+
return construct("blockstack").then(w => worker = w);
181
+
},
182
+
184
183
185
-
deconstruct: resolved(() => {
184
+
deconstruct() {
186
185
worker.terminate();
187
186
worker = null;
188
-
}),
187
+
188
+
return Promise.resolve();
189
+
},
190
+
189
191
190
192
// In & Out
191
193
192
-
isSignedIn: resolved(
193
-
blockstack.isUserSignedIn
194
-
),
195
194
196
-
isSigningIn: resolved(
197
-
blockstack.isSignInPending
198
-
),
195
+
isSignedIn:
196
+
() => Promise.resolve(blockstack.isUserSignedIn()),
197
+
199
198
200
-
handleSignInProcess: promised((resolve, reject) => {
201
-
blockstack.handlePendingSignIn().then(
202
-
user => resolve("ModifyUrl"),
203
-
err => reject(err)
204
-
);
205
-
}),
199
+
isSigningIn:
200
+
() => Promise.resolve(blockstack.isSignInPending()),
201
+
202
+
203
+
handleSignInProcess:
204
+
() => blockstack.handlePendingSignIn().then(_ => "ModifyUrl"),
205
+
206
206
207
-
signIn: resolved(() => {
207
+
signIn() {
208
208
blockstack.redirectToSignIn();
209
-
return "Redirect";
210
-
}),
209
+
return Promise.resolve("Redirect");
210
+
},
211
211
212
-
signOut: resolved(() => {
212
+
213
+
signOut() {
213
214
blockstack.signUserOut();
214
-
}),
215
+
return Promise.resolve();
216
+
},
215
217
216
-
// Get data
217
218
218
-
getData: promised((resolve, reject) => {
219
-
blockstack.getFile(KEY).then(
220
-
resolve,
221
-
reject
222
-
);
223
-
}),
219
+
// Data
220
+
221
+
222
+
getData: _ => blockstack.getFile(KEY),
224
223
225
-
// Store data
226
224
227
-
storeData: json => new Promise((resolve, reject) => {
228
-
blockstack.putFile(KEY, json).then(
229
-
_ => resolve(),
230
-
err => reject(err)
231
-
);
232
-
})
225
+
storeData: json => blockstack.putFile(KEY, json)
233
226
234
227
}
235
228
···
242
235
243
236
(() => {
244
237
245
-
const KEY = "isotach";
246
-
247
-
let isConstructed = false;
248
238
let rs;
249
239
let worker;
250
240
251
241
252
242
function setInstance() {
253
-
if (!rs) {
254
-
rs = new RemoteStorage({ cache: false });
255
-
rs.access.claim(KEY, "rw");
256
-
}
243
+
if (rs) return;
244
+
rs = new RemoteStorage({ cache: false });
245
+
rs.access.claim("isotach", "rw");
257
246
}
258
247
259
248
function destroyInstance() {
260
-
if (rs) {
261
-
rs.disconnect();
262
-
rs = null;
263
-
}
249
+
if (!rs) return;
250
+
rs.disconnect();
251
+
rs = null;
264
252
}
265
253
266
254
267
255
AUTH_SYSTEM.REMOTE_STORAGE = {
268
256
269
-
construct: () => (
270
-
construct("remoteStorage").then(w => worker = w)
271
-
),
257
+
construct() {
258
+
return construct("remoteStorage").then(w => worker = w);
259
+
},
260
+
272
261
273
-
deconstruct: resolved(() => {
262
+
deconstruct() {
274
263
worker.terminate();
275
264
worker = null;
276
-
}),
265
+
266
+
return Promise.resolve();
267
+
},
268
+
277
269
278
270
// In & Out
279
271
280
-
isSignedIn: promised((resolve, reject) => {
281
-
let timeoutId;
282
272
273
+
isSignedIn: _ => new Promise((resolve, reject) => {
283
274
setInstance();
284
275
285
-
rs.on(
286
-
"connected",
287
-
() => {
288
-
clearTimeout(timeoutId);
289
-
resolve(true);
290
-
rs.off("connected");
291
-
}
292
-
);
276
+
const timeoutId = setTimeout(() => {
277
+
resolve(false);
278
+
rs.off("connected");
279
+
}, 10000);
293
280
294
-
timeoutId = setTimeout(
295
-
() => {
296
-
resolve(false);
297
-
rs.off("connected");
298
-
},
299
-
10000
300
-
);
281
+
rs.on("connected", _ => {
282
+
clearTimeout(timeoutId);
283
+
resolve(true);
284
+
rs.off("connected");
285
+
});
301
286
}),
302
287
303
-
isSigningIn: Promise.resolve(
304
-
false
305
-
),
288
+
289
+
isSigningIn:
290
+
() => Promise.resolve(false),
291
+
292
+
293
+
handleSignInProcess:
294
+
() => Promise.resolve("KeepUrl"),
306
295
307
-
handleSignInProcess: Promise.resolve(
308
-
"KeepUrl"
309
-
),
310
296
311
-
signIn: promised((resolve, reject) => {
297
+
signIn: _ => new Promise((resolve, reject) => {
312
298
const userAddress = prompt(
313
299
"Which user address would you like to use?"
314
300
);
···
324
310
rs.connect(userAddress);
325
311
}),
326
312
327
-
signOut: resolved(() => {
313
+
314
+
signOut() {
328
315
setInstance();
329
316
destroyInstance();
330
-
}),
331
317
332
-
// Get data
318
+
return Promise.resolve();
319
+
},
333
320
334
-
getData: promised((resolve, reject) => {
321
+
322
+
// Data
323
+
324
+
325
+
getData: _ => new Promise((resolve, reject) => {
335
326
const handler = event => {
336
327
switch (event.data.action) {
337
328
case "GET_SUCCESS": return event.data.data
···
352
343
});
353
344
}),
354
345
355
-
// Store data
356
346
357
347
storeData: json => new Promise((resolve, reject) => {
358
348
const handler = event => {