3 |
4 | Sign In
7 | Sign Up
8 |
9 |
10 | My Account
11 |
12 | Sign Out
13 | Change Password
14 | Delete Account
15 |
16 |
17 |
18 |
22 | Delete Account
23 |
24 | Are you sure to delete your account?
25 | All your stored schemas would be lost! 26 |
27 |
28 | Cancel
29 | Confirm
30 |
31 |
32 |
33 |
34 |
35 |
106 |
107 |
121 |
--------------------------------------------------------------------------------
/src/components/ContextMenu.vue:
--------------------------------------------------------------------------------
1 |
2 | Json Schema Editor
5 | 6 |
19 |
21 | 25 | All your stored schemas would be lost! 26 |
3 |
4 |
16 |
17 |
18 |
33 |
34 |
35 |
36 |
129 |
166 |
--------------------------------------------------------------------------------
/src/components/ContextMenuItem.vue:
--------------------------------------------------------------------------------
1 |
2 |
9 |
17 |
18 |
211 |
239 |
--------------------------------------------------------------------------------
/src/components/Toolbox.vue:
--------------------------------------------------------------------------------
1 |
2 |
10 |
12 |
13 |
15 |
16 |
3 |
9 |
10 |
11 |
12 |
118 |
125 |
--------------------------------------------------------------------------------
/src/components/ToolboxComponent.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
17 |
18 |
91 |
114 |
--------------------------------------------------------------------------------
/src/components/Tree.vue:
--------------------------------------------------------------------------------
1 |
2 |
11 | ![]()
12 | {{node.type}}
13 | :
14 | {{node.name}}
15 |
16 | -
3 |
-
30 |
3 |
4 |
5 |
6 |
8 |
9 |
10 |
24 |
28 |
29 |
30 | Change Password
31 |
32 |
33 |
34 |
35 |
36 |
75 |
85 |
--------------------------------------------------------------------------------
/src/components/account/SignIn.vue:
--------------------------------------------------------------------------------
1 |
2 | Change Password
7 |
25 |
26 |
27 |
3 |
4 |
5 |
6 |
8 |
9 |
10 |
20 |
24 |
25 |
26 | Forgot password
27 | Sign In
28 |
29 |
30 |
31 |
32 |
33 |
73 |
82 |
--------------------------------------------------------------------------------
/src/components/account/SignUp.vue:
--------------------------------------------------------------------------------
1 |
2 | Sign In
7 |
21 |
22 |
23 |
3 |
4 |
5 |
6 |
8 |
9 |
10 |
24 |
28 |
29 |
30 | Sign Up
31 |
32 |
33 |
34 |
35 |
36 |
84 |
94 |
--------------------------------------------------------------------------------
/src/components/account/VerifyEmail.vue:
--------------------------------------------------------------------------------
1 |
2 | Sign Up
7 |
25 |
26 |
27 |
3 |
4 |
5 |
6 |
8 |
9 |
10 |
20 |
24 |
25 |
26 | Resend Verification Code
27 | Verify
28 |
29 |
30 |
31 |
32 |
33 |
72 |
82 |
--------------------------------------------------------------------------------
/src/components/context-menu-items/ButtonMenuItem.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 | Verify User Email
7 |
21 |
22 |
23 |
3 | UPDATE
16 |
17 |
18 |
89 |
106 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/DependencyItemInspector.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
11 |
12 | {{prop.name}}
13 |
15 |
3 | UPDATE
7 |
8 |
9 |
50 |
60 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/EnumInspector.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 | {{item.name}}
5 |
6 |
3 |
11 |
12 |
14 |
20 |
21 |
92 |
125 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/Property.js:
--------------------------------------------------------------------------------
1 | export class Property {
2 | constructor (type, name) {
3 | this.type = type
4 | this.name = name
5 | this.value = null
6 | this.exist = false
7 | this.errMsg = null
8 | }
9 |
10 | setValue (value) {
11 | this.exist = typeof value !== 'undefined'
12 | this.value = value
13 | this.errMsg = null
14 | }
15 |
16 | getValue () {
17 | if (this.type === 'integer') {
18 | return this.exist ? Number.parseInt(this.value) : undefined
19 | }
20 | if (this.type === 'number') {
21 | return this.exist ? Number.parseFloat(this.value) : undefined
22 | }
23 | return this.exist ? this.value : undefined
24 | }
25 | }
26 |
27 | export default Property
28 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/RefInspector.vue:
--------------------------------------------------------------------------------
1 |
2 | enum items
4 |
5 |
10 |
6 |
9 | {{errorMessage}}
15 |
16 | UPDATE
17 | Add
18 |
19 |
3 |
4 |
5 |
7 | UPDATE
8 |
9 |
10 |
33 |
43 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/RequiredInspector.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 | UPDATE
7 |
8 |
9 |
48 |
58 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/inspectors/index.js:
--------------------------------------------------------------------------------
1 | import requiredInspector from './RequiredInspector.vue'
2 | import dependencyItemInspector from './DependencyItemInspector.vue'
3 | import enumInspector from './EnumInspector.vue'
4 | import refInspector from './RefInspector.vue'
5 | import BasicInspector from './BasicInspector.vue'
6 |
7 | export default {
8 | requiredInspector,
9 | dependencyItemInspector,
10 | enumInspector,
11 | refInspector,
12 | BasicInspector
13 | }
14 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/menuData.js:
--------------------------------------------------------------------------------
1 | export var menuData = {
2 | menuItems: [
3 | {
4 | name: 'remove',
5 | label: 'Remove',
6 | disabled (source) {
7 | return !(source.node.parent)
8 | },
9 | action (source) {
10 | source.remove()
11 | }
12 | },
13 | {
14 | name: 'moveUp',
15 | label: 'Move Up',
16 | disabled (source) {
17 | return !(source.node.parent)
18 | },
19 | action: source => {
20 | source.moveUp()
21 | }
22 | },
23 | {
24 | name: 'moveDown',
25 | label: 'Move Down',
26 | disabled (source) {
27 | return !(source.node.parent)
28 | },
29 | action: source => {
30 | source.moveDown()
31 | }
32 | }
33 | ]
34 | }
35 |
36 | export default menuData
37 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/repository-firebase.js:
--------------------------------------------------------------------------------
1 | import * as firebase from 'firebase'
2 | import { Database, UserNotSignInError } from '../../firebase'
3 | import $RefParser from 'json-schema-ref-parser'
4 |
5 | // define custom error for repository has not initialized
6 | export function RepositoryNotInitError (message) {
7 | this.name = 'RepositoryNotInitError'
8 | this.message = message || 'Repository has not initialized.'
9 | this.stack = (new Error()).stack
10 | }
11 | RepositoryNotInitError.prototype = Object.create(Error.prototype)
12 | RepositoryNotInitError.prototype.constructor = RepositoryNotInitError
13 |
14 | // define custom error for schema not exist
15 | export function SchemaNotExistError (message) {
16 | this.name = 'SchemaNotExistError'
17 | this.message = message || 'Schema not exist.'
18 | this.stack = (new Error()).stack
19 | }
20 | SchemaNotExistError.prototype = Object.create(Error.prototype)
21 | SchemaNotExistError.prototype.constructor = SchemaNotExistError
22 |
23 | // encode key to URL Encoded string
24 | function EncodeSchema (schema) {
25 | var result = Array.isArray(schema) ? [] : {}
26 | for (var prop in schema) {
27 | var value = schema[prop]
28 | if (typeof value === 'object') {
29 | result[encodeURIComponent(prop)] = EncodeSchema(value)
30 | } else {
31 | result[encodeURIComponent(prop)] = value
32 | }
33 | }
34 | return result
35 | }
36 |
37 | // decode key from URL Encoded string
38 | function DecodeSchema (schema) {
39 | var result = Array.isArray(schema) ? [] : {}
40 | for (var prop in schema) {
41 | var value = schema[prop]
42 | if (typeof value === 'object') {
43 | result[decodeURIComponent(prop)] = DecodeSchema(value)
44 | } else {
45 | result[decodeURIComponent(prop)] = value
46 | }
47 | }
48 | return result
49 | }
50 |
51 | export class Repository {
52 | constructor () {
53 | this.database = new Database()
54 | this.uid = null
55 | // firebase resolver for json-schema-ref-parser
56 | this.firebaseResolver = {
57 | order: 1,
58 | canRead: /^repository:/i,
59 | read: async (file) => {
60 | let schemaName = file.url.substr(13)
61 | return await this.retrieveSchema(schemaName, false)
62 | }
63 | }
64 | }
65 |
66 | async init () {
67 | return new Promise((resolve, reject) => {
68 | if (firebase.auth().currentUser) {
69 | this.uid = firebase.auth().currentUser.uid
70 | resolve()
71 | } else {
72 | reject(new UserNotSignInError())
73 | }
74 | })
75 | }
76 |
77 | async retrieveSchema (schemaName, dereference) {
78 | if (!this.uid) throw new RepositoryNotInitError()
79 | let reference = `/schemas/${this.uid}/${schemaName}`
80 | let schema = await this.database.readValue(reference)
81 | if (schema) {
82 | schema = DecodeSchema(schema) // decode schema
83 | if (dereference || typeof dereference === 'undefined') {
84 | try {
85 | return await $RefParser.dereference(schema, { resolve: { firebase: this.firebaseResolver } })
86 | } catch (err) {
87 | // return un-dereference schema
88 | }
89 | }
90 | return schema
91 | } else {
92 | throw new SchemaNotExistError()
93 | }
94 | }
95 |
96 | async retrieveAllSchemas () {
97 | if (!this.uid) throw new RepositoryNotInitError()
98 | let reference = `/schemas/${this.uid}`
99 | let queryResult = await this.database.readSnapshot(reference)
100 | let schemas = []
101 | queryResult.forEach(item => {
102 | schemas.push(DecodeSchema(item.val())) // decode schema
103 | })
104 | return schemas
105 | }
106 |
107 | async retrieveTypes () {
108 | if (!this.uid) throw new RepositoryNotInitError()
109 | let reference = `/schemas/${this.uid}`
110 | let types = await this.database.list(reference)
111 | return types
112 | }
113 |
114 | async saveSchema (schema, schemaName) {
115 | if (!this.uid) throw new RepositoryNotInitError()
116 | let reference = `/schemas/${this.uid}/${schemaName}`
117 | await this.database.write(reference, EncodeSchema(schema)) // encode schema
118 | }
119 |
120 | async deleteSchema (schemaName) {
121 | if (!this.uid) throw new RepositoryNotInitError()
122 | let reference = `/schemas/${this.uid}/${schemaName}`
123 | await this.database.delete(reference)
124 | }
125 |
126 | async deleteAllSchemas () {
127 | if (!this.uid) throw new RepositoryNotInitError()
128 | let reference = `/schemas/${this.uid}`
129 | await this.database.delete(reference)
130 | }
131 | }
132 |
133 | export var repository = new Repository()
134 |
135 | export default repository
136 |
137 |
--------------------------------------------------------------------------------
/src/components/json-schema-editor/treeData.js:
--------------------------------------------------------------------------------
1 | import Components from './components'
2 |
3 | export var treeData = new Components.JsonSchemaComponent()
4 |
5 | export default treeData
6 |
--------------------------------------------------------------------------------
/src/components/tree/store.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | function generateId () {
4 | return (new Date()).getTime() + ('000000000' + Math.floor((Math.random() * 10000) + 1)).substr(-4)
5 | }
6 |
7 | function resolveDupName (node, parent) {
8 | var origName = node.name
9 | var count = 0
10 | parent.children.forEach(child => {
11 | let reg = new RegExp(`^${RegExp.escape(origName)}(\\(\\d+\\))?$`, 'g')
12 | if (reg.test(child.name)) count++
13 | })
14 | if (count > 0) {
15 | node.name = `${origName}(${count})`
16 | }
17 | }
18 |
19 | function functionName (func) {
20 | // Match:
21 | // - ^ the beginning of the string
22 | // - function the word 'function'
23 | // - \s+ at least some white space
24 | // - ([\w\$]+) capture one or more valid JavaScript identifier characters
25 | // - \s* optionally followed by white space (in theory there won't be any here,
26 | // so if performance is an issue this can be omitted[1]
27 | // - \( followed by an opening brace
28 | //
29 | let result = /^function\s+([\w$]+)\s*\(/.exec(func.toString())
30 |
31 | return result ? result[1] : '' // for an anonymous function there won't be a match
32 | }
33 |
34 | var selectedNode
35 |
36 | function populateTree (node, parent) {
37 | let root = new TreeNode(node.type, node.name, node.value, node.valueSchema,
38 | parent, node.icon, node.funcs, node.editable, node.draggable, node.droppable,
39 | node.expended, node.selected)
40 | if (root.selected) selectedNode = root
41 | if (node.children) {
42 | root.children = []
43 | node.children.forEach(child => {
44 | root.children.push(populateTree(child, root))
45 | })
46 | }
47 | return root
48 | }
49 |
50 | class TreeNode {
51 | constructor (type, name, value, valueSchema, parent, icon, funcs, editable, draggable, droppable, expended, selected) {
52 | this.id = generateId()
53 | this.type = type
54 | this.name = name
55 | this.valueSchema = valueSchema || { type: 'object' }
56 | // consider use default of schema when value is null
57 | this.value = value
58 | this.parent = parent
59 | this.icon = icon
60 | this.funcs = funcs
61 | this.editable = typeof editable === 'undefined' ? true : editable
62 | this.draggable = typeof draggable === 'undefined' ? true : draggable
63 | this.droppable = typeof droppable === 'undefined' ? true : droppable
64 | this.expended = expended
65 | this.selected = selected
66 | this.editing = false
67 | }
68 |
69 | isAncestor (node) {
70 | if (this === node) return true
71 | if (this.parent) return this.parent.isAncestor(node)
72 | else return false
73 | }
74 |
75 | append (child) {
76 | // if child is not TreeNode, then create TreeNode
77 | let newNode = (child.prototype && functionName(child.prototype) === 'TreeNode') ? child : populateTree(child)
78 | if (newNode.name) resolveDupName(newNode, this)
79 | Vue.set(newNode, 'parent', this)
80 | this.children.push(newNode)
81 | Vue.set(this, 'expended', true)
82 | }
83 |
84 | remove () {
85 | if (this.parent) {
86 | let children = this.parent.children
87 | let index = children.indexOf(this)
88 | children.splice(index, 1)
89 | Vue.set(this, 'parent', null)
90 | }
91 | }
92 |
93 | moveUp () {
94 | if (this.parent) {
95 | let children = this.parent.children
96 | let index = children.indexOf(this)
97 | if (index <= 0) return
98 | children.splice(index, 1)
99 | children.splice(index - 1, 0, this)
100 | }
101 | }
102 |
103 | moveDown () {
104 | if (this.parent) {
105 | let children = this.parent.children
106 | let index = children.indexOf(this)
107 | if (index === -1 || index === children.length - 1) return
108 | children.splice(index, 1)
109 | children.splice(index + 1, 0, this)
110 | }
111 | }
112 | }
113 |
114 | class Store {
115 | constructor () {
116 | this.tree = null
117 | this.selectedNode = null
118 | }
119 |
120 | init (tree) {
121 | selectedNode = null
122 | this.tree = populateTree(tree)
123 | if (selectedNode) {
124 | this.selectedNode = selectedNode
125 | } else {
126 | this.tree.selected = true
127 | this.selectedNode = this.tree
128 | }
129 | }
130 |
131 | toggle (node) {
132 | node.expended = !node.expended
133 | }
134 |
135 | select (node) {
136 | if (this.selectedNode) {
137 | this.selectedNode.selected = false
138 | this.selectedNode.editing = false
139 | }
140 | this.selectedNode = node
141 | node.selected = true
142 | }
143 |
144 | startEdit (node) {
145 | node.editing = true
146 | }
147 |
148 | stopEdit (node) {
149 | node.editing = false
150 | }
151 |
152 | rename (node, name) {
153 | node.name = name
154 | node.editing = false
155 | }
156 |
157 | append (node, child) {
158 | node.append(child)
159 | }
160 |
161 | remove (node) {
162 | node.remove()
163 | }
164 |
165 | moveUp (node) {
166 | node.moveUp()
167 | }
168 |
169 | moveDown (node) {
170 | node.moveDown()
171 | }
172 | }
173 |
174 | export default Store
175 |
--------------------------------------------------------------------------------
/src/firebase/index.js:
--------------------------------------------------------------------------------
1 | import * as firebase from 'firebase'
2 |
3 | // Initialize firebase
4 | // Replace following config with your Firebase config
5 | var config = {
6 | apiKey: 'your firebase api key',
7 | authDomain: 'your firebase auth domain',
8 | databaseURL: 'your firebase database url',
9 | projectId: 'your firebase project id',
10 | storageBucket: 'your firebase storage bucket',
11 | messagingSenderId: 'your firebase message sender id'
12 | }
13 | firebase.initializeApp(config)
14 |
15 | // define custom error for schema not exist
16 | export function UserNotSignInError (message) {
17 | this.name = 'UserNotSignInError'
18 | this.message = message || 'No sign in user.'
19 | this.stack = (new Error()).stack
20 | }
21 | UserNotSignInError.prototype = Object.create(Error.prototype)
22 | UserNotSignInError.prototype.constructor = UserNotSignInError
23 |
24 | export class Authentication {
25 | constructor () {
26 | this.service = firebase.auth()
27 | this.currentUser = null
28 | this.callbacks = []
29 | this.service.onAuthStateChanged(user => {
30 | this.currentUser = user
31 | this.callbacks.forEach(callback => {
32 | callback(user)
33 | })
34 | })
35 | this.options = {
36 | requireVerifyEmail: false,
37 | sendVerifyEmailExplicitly: true,
38 | requireOldPassword: false
39 | }
40 | }
41 |
42 | addListener (callback) {
43 | this.callbacks.push(callback)
44 | }
45 |
46 | removeListener (callback) {
47 | let idx = this.callbacks.indexOf(callback)
48 | if (idx >= 0) this.callbacks.splice(idx, 1)
49 | }
50 |
51 | async signUp (email, password) {
52 | return new Promise((resolve, reject) => {
53 | this.service.createUserWithEmailAndPassword(email, password)
54 | .then(user => {
55 | resolve(user)
56 | })
57 | .catch(error => {
58 | reject(error)
59 | })
60 | })
61 | }
62 |
63 | async sendVerificationEmail () {
64 | if (this.currentUser) {
65 | return new Promise((resolve, reject) => {
66 | this.currentUser.sendEmailVerification()
67 | .then(() => {
68 | resolve()
69 | })
70 | .catch(error => {
71 | reject(error)
72 | })
73 | })
74 | } else {
75 | throw new UserNotSignInError()
76 | }
77 | }
78 |
79 | async verifyEmail (code) {
80 | return new Promise((resolve, reject) => {
81 | this.service.applyActionCode(code)
82 | .then(() => {
83 | resolve()
84 | })
85 | .catch(error => {
86 | reject(error)
87 | })
88 | })
89 | }
90 |
91 | async signIn (email, password) {
92 | return new Promise((resolve, reject) => {
93 | this.service.signInWithEmailAndPassword(email, password)
94 | .then(user => {
95 | resolve(user)
96 | })
97 | .catch(error => {
98 | reject(error)
99 | })
100 | })
101 | }
102 |
103 | async changePassword (newPassword) {
104 | if (this.currentUser) {
105 | return new Promise((resolve, reject) => {
106 | this.currentUser.updatePassword(newPassword)
107 | .then(() => {
108 | resolve()
109 | })
110 | .catch(error => {
111 | reject(error)
112 | })
113 | })
114 | } else {
115 | throw new UserNotSignInError()
116 | }
117 | }
118 |
119 | async resetPassword (email) {
120 | return new Promise((resolve, reject) => {
121 | this.service.sendPasswordResetEmail(email)
122 | .then(() => {
123 | resolve()
124 | })
125 | .catch(error => {
126 | reject(error)
127 | })
128 | })
129 | }
130 |
131 | async confirmPasswordReset (code, newPassword) {
132 | return new Promise((resolve, reject) => {
133 | this.service.confirmPasswordReset(code, newPassword)
134 | .then(() => {
135 | resolve()
136 | })
137 | .catch(error => {
138 | reject(error)
139 | })
140 | })
141 | }
142 |
143 | async deleteUser () {
144 | if (this.currentUser) {
145 | return new Promise((resolve, reject) => {
146 | this.currentUser.delete()
147 | .then(() => {
148 | resolve()
149 | })
150 | .catch(error => {
151 | reject(error)
152 | })
153 | })
154 | } else {
155 | throw new UserNotSignInError()
156 | }
157 | }
158 |
159 | async signOut () {
160 | return new Promise((resolve, reject) => {
161 | this.service.signOut()
162 | .then(() => {
163 | resolve()
164 | })
165 | .catch(error => {
166 | reject(error)
167 | })
168 | })
169 | }
170 |
171 | async retrieveCurrentUser () {
172 | return new Promise((resolve, reject) => {
173 | this.currentUser = this.service.currentUser
174 | if (this.currentUser) {
175 | resolve(this.currentUser)
176 | } else {
177 | reject(new UserNotSignInError())
178 | }
179 | })
180 | }
181 | }
182 |
183 | export var authentication = new Authentication()
184 |
185 | export class Storage {
186 | constructor () {
187 | this.service = firebase.storage()
188 | }
189 | }
190 |
191 | export class Database {
192 | constructor () {
193 | this.service = firebase.database()
194 | }
195 |
196 | async readSnapshot (reference) {
197 | return new Promise((resolve, reject) => {
198 | this.service.ref(reference).orderByKey().once('value')
199 | .then((snapshot) => {
200 | resolve(snapshot)
201 | })
202 | .catch(error => {
203 | reject(error)
204 | })
205 | })
206 | }
207 |
208 | async readValue (reference) {
209 | return new Promise((resolve, reject) => {
210 | this.service.ref(reference).orderByKey().once('value')
211 | .then((snapshot) => {
212 | resolve(snapshot.val())
213 | })
214 | .catch(error => {
215 | reject(error)
216 | })
217 | })
218 | }
219 |
220 | async list (reference) {
221 | return new Promise((resolve, reject) => {
222 | this.service.ref(reference).orderByKey().once('value')
223 | .then((snapshot) => {
224 | let list = []
225 | snapshot.forEach(child => {
226 | list.push(child.key)
227 | })
228 | resolve(list)
229 | })
230 | .catch(error => {
231 | reject(error)
232 | })
233 | })
234 | }
235 |
236 | async write (reference, data) {
237 | return new Promise((resolve, reject) => {
238 | this.service.ref(reference).set(data)
239 | .then(() => {
240 | resolve()
241 | })
242 | .catch(error => {
243 | reject(error)
244 | })
245 | })
246 | }
247 |
248 | async delete (reference) {
249 | return new Promise((resolve, reject) => {
250 | this.service.ref(reference).remove()
251 | .then(() => {
252 | resolve()
253 | })
254 | .catch(error => {
255 | reject(error)
256 | })
257 | })
258 | }
259 | }
260 |
--------------------------------------------------------------------------------
/src/main.js:
--------------------------------------------------------------------------------
1 | // The Vue build version to load with the `import` command
2 | // (runtime-only or standalone) has been set in webpack.base.conf with an alias.
3 | import Vue from 'vue'
4 | import VueMaterial from 'vue-material'
5 | import 'vue-material/dist/vue-material.css'
6 | import 'material-icons/css/material-icons.css'
7 | import App from './App'
8 | import router from './router'
9 |
10 | Vue.use(VueMaterial)
11 | Vue.material.registerTheme('default', {
12 | primary: 'blue'
13 | })
14 | Vue.config.productionTip = false
15 |
16 | /* eslint-disable no-new */
17 | new Vue({
18 | el: '#app',
19 | router,
20 | template: '
4 | {{item.name}}
5 |
6 |