@insignia-education/api-sdk-js 0.9.22 → 0.9.24

package/tests/integration/api/v1/courses/index.test.js

@@ -0,0 +1,46 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/courses', () => {
+    test('get | returns paginated list', async () => {
+        await api.courses.get()
+            .then(response => {
+                console.log(response);
+                expect(response["data"]).toBeDefined();
+                expect(response["current_page"]).toBeDefined();
+                expect(response["last_page"]).toBeDefined();
+                expect(response["per_page"]).toBeDefined();
+                expect(response["total"]).toBeDefined();
+                expect(Array.isArray(response["data"])).toBe(true);
+                expect(response["data"].length > 0).toBe(true);
+                response["data"].forEach(course => {
+                    expect(course["id"]).toBeDefined();
+                    expect(course["cod"]).toBeDefined();
+                    expect(course["title"]).toBeDefined();
+                    expect(course["enabled"]).toBeDefined();
+                });
+            });
+    });
+
+    test('get | page 2', async () => {
+        await api.courses.get(null, { page: 2 })
+            .then(response => {
+                expect(response["data"]).toBeDefined();
+                expect(response["current_page"]).toBe(2);
+            });
+    });
+
+    test('get by id | returns single course', async () => {
+        const firstPage = await api.courses.get();
+        const id = firstPage["data"][0]["id"];
+        await api.courses.get(id)
+            .then(response => {
+                expect(response["id"]).toBe(id);
+                expect(response["cod"]).toBeDefined();
+                expect(response["title"]).toBeDefined();
+            });
+    });
+});

package/tests/integration/api/v1/currencies/index.test.js

@@ -0,0 +1,24 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/currencies', () => {
+    test('get', async () => {
+        api.currencies.get()
+        .then(response => {
+            expect(response["1"]).toBeDefined();
+            expect(response["1"]["id"]).toBeDefined();
+            expect(response["1"]["country_id"]).toBeDefined();
+            expect(response["1"]["cod"]).toBeDefined();
+            expect(response["1"]["title"]).toBeDefined();
+            expect(response["1"]["enabled"]).toBeDefined();
+            expect(response["1"]["has_double_expression"]).toBeDefined();
+            expect(response["1"]["double_expression_by"]).toBeDefined();
+            expect(response["1"]["created_at"]).toBeDefined();
+            expect(response["1"]["updated_at"]).toBeDefined();
+            expect(response["1"]["deleted_at"]).toBeDefined();
+        });
+    });
+});

package/tests/integration/api/v1/currencies/values.test.js

@@ -0,0 +1,24 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/currencies/values', () => {
+
+    test('get', async () => {
+        await api.currencies.getValues()
+        .then(response => {
+            response = Object.values(response);
+            expect(response.length > 0).toBe(true);
+            response.forEach(value => {
+                expect(value["id"]).toBeDefined();
+                expect(value["currency_id"]).toBeDefined();
+                expect(value["value"]).toBeDefined();
+                expect(value["created_at"]).toBeDefined();
+                expect(value["updated_at"]).toBeDefined();
+            })
+            
+        });
+    });
+});

package/tests/integration/api/v1/files.test.js

@@ -0,0 +1,25 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/files', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.files.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(file => {
+                    expect(file["id"]).toBeDefined();
+                    expect(file["path"]).toBeDefined();
+                    expect(file["created_at"]).toBeDefined();
+                    expect(file["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/forums/index.test.js

@@ -0,0 +1,23 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/forums', () => {
+    test('get | authenticated', async () => {
+        await loginCustomer();
+        await api.forums.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(forum => {
+                    expect(forum["id"]).toBeDefined();
+                    expect(forum["title"]).toBeDefined();
+                    expect(forum["enabled"]).toBeDefined();
+                    expect(forum["created_at"]).toBeDefined();
+                    expect(forum["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/hashes.test.js

@@ -0,0 +1,26 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/hashes', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.hashes.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(hash => {
+                    expect(hash["id"]).toBeDefined();
+                    expect(hash["hash"]).toBeDefined();
+                    expect(hash["purpose_id"]).toBeDefined();
+                    expect(hash["created_at"]).toBeDefined();
+                    expect(hash["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/insignias.test.js

@@ -0,0 +1,19 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+describe('api/v1/insignias', () => {
+    test('get', async () => {
+        await api.insignias.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(insignia => {
+                    expect(insignia["id"]).toBeDefined();
+                    expect(insignia["cod"]).toBeDefined();
+                    expect(insignia["title"]).toBeDefined();
+                    expect(insignia["enabled"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/languages.test.js

@@ -0,0 +1,28 @@
+
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+
+describe('api/v1/languages', () => {
+    test('get', async () => {
+        await api.languages.get()
+        .then(response => {
+            response = Object.values(response);
+            expect(response.length > 0).toBe(true);
+            response.forEach(language => {
+                expect(language["id"]).toBeDefined();
+                expect(language["iso"]).toBeDefined();
+                expect(language["flag_emoji"]).toBeDefined();
+                expect(language["enabled"]).toBeDefined();
+                expect(language["default"]).toBeDefined();
+                expect(language["created_at"]).toBeDefined();
+                expect(language["updated_at"]).toBeDefined();
+                expect(language["deleted_at"]).toBeDefined();
+            })
+            
+        });
+    });
+});
+
+

package/tests/integration/api/v1/mail-blacklist.test.js

@@ -0,0 +1,26 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/mail-blacklist', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.mailBlacklist.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(entry => {
+                    expect(entry["id"]).toBeDefined();
+                    expect(entry["email"]).toBeDefined();
+                    expect(entry["type_id"]).toBeDefined();
+                    expect(entry["created_at"]).toBeDefined();
+                    expect(entry["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/organizations.test.js

@@ -0,0 +1,25 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/organizations', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.organizations.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(org => {
+                    expect(org["id"]).toBeDefined();
+                    expect(org["name"]).toBeDefined();
+                    expect(org["created_at"]).toBeDefined();
+                    expect(org["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/payment-methods/by-currencies.test.js

@@ -0,0 +1,51 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+describe('api/v1/payment-methods/by-currency/1', () => {
+    test('get', async () => {
+        await api.currencies.get()
+            .then(response => {
+                Object.values(response).forEach(async currency => {
+                    await api.paymentMethods.byCurrency(currency.id)
+                        .then(response => {
+                            response = Object.values(response);
+                            if(response.length == 0){
+                                return;
+                            }
+                            expect(response[0]["id"]).toBeDefined();
+                            expect(response[0]["currency_id"]).toBeDefined();
+                            expect(response[0]["order"]).toBeDefined();
+                            expect(response[0]["cod"]).toBeDefined();
+                            expect(response[0]["title"]).toBeDefined();
+                            expect(response[0]["requires_reference"]).toBeDefined();
+                            expect(response[0]["can_upload_support"]).toBeDefined();
+                            expect(response[0]["enabled"]).toBeDefined();
+                            expect(response[0]["commission_amount"]).toBeDefined();
+                            expect(response[0]["commission_percentage"]).toBeDefined();
+                            expect(response[0]["description"]).toBeDefined();
+                            expect(response[0]["image"]).toBeDefined();
+                            expect(response[0]["icon"]).toBeDefined();
+                            expect(response[0]["created_at"]).toBeDefined();
+                            expect(response[0]["updated_at"]).toBeDefined();
+                            expect(response[0]["deleted_at"]).toBeDefined();
+                        })
+                })
+            })
+    });
+});
+
+describe('users/cash-receivers', () => {
+    test('get By currency id() returns a list', async () => {
+        await api.users.cashReceivers()
+            .then(response => {
+                expect(response.length > 0).toBe(true);
+                response.forEach(user => {
+                    expect(user["id"]).toBeDefined();
+                    expect(user["name"]).toBeDefined();
+                })
+            })
+    });
+});
+

package/tests/integration/api/v1/quizzes/index.test.js

@@ -0,0 +1,39 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+describe('api/v1/quizzes', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.quizzes.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(quiz => {
+                    expect(quiz["id"]).toBeDefined();
+                    expect(quiz["cod"]).toBeDefined();
+                    expect(quiz["enabled"]).toBeDefined();
+                    expect(quiz["created_at"]).toBeDefined();
+                    expect(quiz["updated_at"]).toBeDefined();
+                });
+            });
+    });
+
+    test('get questions | authenticated', async () => {
+        await loginAdmin();
+        const quizzes = await api.quizzes.get().then(r => Object.values(r));
+        if (quizzes.length === 0) return;
+        const quizId = quizzes[0]["id"];
+        await api.quizzes.questions(quizId).get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(question => {
+                    expect(question["id"]).toBeDefined();
+                    expect(question["quiz_id"]).toBeDefined();
+                    expect(question["question"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/short-links.test.js

@@ -0,0 +1,27 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/short-links', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.shortLinks.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(link => {
+                    expect(link["id"]).toBeDefined();
+                    expect(link["cod"]).toBeDefined();
+                    expect(link["url"]).toBeDefined();
+                    expect(link["enabled"]).toBeDefined();
+                    expect(link["created_at"]).toBeDefined();
+                    expect(link["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/surveys/index.test.js

@@ -0,0 +1,40 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/surveys', () => {
+    test('get | authenticated', async () => {
+        await loginCustomer();
+        await api.surveys.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(survey => {
+                    expect(survey["id"]).toBeDefined();
+                    expect(survey["cod"]).toBeDefined();
+                    expect(survey["enabled"]).toBeDefined();
+                    expect(survey["created_at"]).toBeDefined();
+                    expect(survey["updated_at"]).toBeDefined();
+                });
+            });
+    });
+
+    test('get questions | authenticated', async () => {
+        await loginCustomer();
+        const surveys = await api.surveys.get().then(r => Object.values(r));
+        if (surveys.length === 0) return;
+        const surveyId = surveys[0]["id"];
+        await api.surveys.questions(surveyId).get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(question => {
+                    expect(question["id"]).toBeDefined();
+                    expect(question["survey_id"]).toBeDefined();
+                    expect(question["question"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/taxes.test.js

@@ -0,0 +1,20 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+describe('api/v1/taxes', () => {
+    test('get', async () => {
+        await api.taxes.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(tax => {
+                    expect(tax["id"]).toBeDefined();
+                    expect(tax["cod"]).toBeDefined();
+                    expect(tax["title"]).toBeDefined();
+                    expect(tax["percentage"]).toBeDefined();
+                    expect(tax["enabled"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/teacher/index.test.js

@@ -0,0 +1,53 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/teacher/absences', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.teacher.absences().get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(absence => {
+                    expect(absence["id"]).toBeDefined();
+                    expect(absence["created_at"]).toBeDefined();
+                    expect(absence["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});
+
+describe('api/v1/teacher/config-sets', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.teacher.configSets().get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(configSet => {
+                    expect(configSet["id"]).toBeDefined();
+                    expect(configSet["created_at"]).toBeDefined();
+                    expect(configSet["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});
+
+describe('api/v1/teacher/configs', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.teacher.configs().get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(config => {
+                    expect(config["id"]).toBeDefined();
+                    expect(config["created_at"]).toBeDefined();
+                    expect(config["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/user-types.test.js

@@ -0,0 +1,19 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+describe('api/v1/user-types', () => {
+    test('get', async () => {
+        await api.userTypes.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(userType => {
+                    expect(userType["id"]).toBeDefined();
+                    expect(userType["cod"]).toBeDefined();
+                    expect(userType["title"]).toBeDefined();
+                    expect(userType["enabled"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/users/cash-receivers.test.js

@@ -0,0 +1,19 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/users/cash-receivers', () => {
+    test('get', async () => {
+        await api.users.cashReceivers()
+            .then(response => {
+                expect(response.length > 0).toBe(true);
+                response.forEach(user => {
+                    expect(user["id"]).toBeDefined();
+                    expect(user["name"]).toBeDefined();
+                })
+            })
+    });
+});
+

package/tests/integration/api/v1/users/index.test.js

@@ -0,0 +1,35 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/users', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.users.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(user => {
+                    expect(user["id"]).toBeDefined();
+                    expect(user["name"]).toBeDefined();
+                    expect(user["email"]).toBeDefined();
+                    expect(user["created_at"]).toBeDefined();
+                    expect(user["updated_at"]).toBeDefined();
+                });
+            });
+    });
+
+    test('get by id | authenticated', async () => {
+        await loginAdmin();
+        const users = await api.users.get().then(r => Object.values(r));
+        const id = users[0]["id"];
+        await api.users.get(id)
+            .then(response => {
+                expect(response["id"]).toBe(id);
+                expect(response["name"]).toBeDefined();
+                expect(response["email"]).toBeDefined();
+            });
+    });
+});

package/tests/integration/api/v1/zoom.test.js

@@ -0,0 +1,24 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/zoom/meetings', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.zoom.meetings().get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(meeting => {
+                    expect(meeting["id"]).toBeDefined();
+                    expect(meeting["created_at"]).toBeDefined();
+                    expect(meeting["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/src/api/v1/Tags.js

@@ -1,12 +0,0 @@
-export default class Tags {
-    #client;
-
-    constructor(client) {
-        this.#client = client;
-    }
-
-    get(id = null)  { return id ? this.#client.get(`/tags/${id}`) : this.#client.get('/tags'); }
-    create(data)    { return this.#client.put('/tags', data); }
-    edit(id, data)  { return this.#client.patch(`/tags/${id}`, data); }
-    delete(id)      { return this.#client.del(`/tags/${id}`); }
-}

package/src/api/v1/Translations.js

@@ -1,12 +0,0 @@
-export default class Translations {
-    #client;
-
-    constructor(client) {
-        this.#client = client;
-    }
-
-    get(id = null)       { return id ? this.#client.get(`/translations/${id}`) : this.#client.get('/translations'); }
-    create(data)         { return this.#client.put('/translations', data); }
-    delete(id)           { return this.#client.del(`/translations/${id}`); }
-    editText(id, data)   { return this.#client.patch(`/translations/${id}/text`, data); }
-}