@drax/identity-front 0.0.8 → 0.0.10

package/src/providers/gql/RoleGqlProvider.ts

@@ -0,0 +1,74 @@
+import type {IGqlClient, IPaginateClient} from '@drax/common-front'
+import type {IRoleProvider} from "../../interfaces/IRoleProvider";
+import type {IRole} from "../../interfaces/IRole";
+
+
+class RoleGqlProvider implements IRoleProvider {
+
+    gqlClient: IGqlClient
+
+    constructor(gqlClient: IGqlClient) {
+        this.gqlClient = gqlClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.gqlClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.gqlClient.removeHeader('Authorization')
+    }
+
+    async fetchPermissions(): Promise<any> {
+        const query: string = `query fetchPermissions { fetchPermissions }`
+        const variables = {}
+        let data = await this.gqlClient.query(query, variables)
+        return data.fetchPermissions
+    }
+
+    async fetchRole(): Promise<any> {
+        const query: string = `query fetchRole { fetchRole { id name permissions readonly } }`
+        const variables = {}
+        let data = await this.gqlClient.query(query, variables)
+        return data.fetchRole
+    }
+
+    async createRole(payload: IRole): Promise<any> {
+        const query: string = `mutation createRole($input: RoleInput) { 
+        createRole(input: $input) {id name permissions readonly } 
+        }`
+        const variables = {input: payload}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createRole
+    }
+
+    async editRole(id: string, payload: IRole): Promise<IRole> {
+        const query: string = `mutation updateRole($id: ID!, $input: RoleInput) { updateRole(id: $id, input: $input) {  
+        id name permissions readonly  } }`
+        const variables = {id, input: payload}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createRole
+    }
+
+    async deleteRole(id: string): Promise<any> {
+        const query: string = `mutation deleteRole($id: ID!) { deleteRole(id: $id) }`
+        const variables = {id: id}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createRole
+    }
+
+    async paginateRole(page: number, limit: number, search:string = ""): Promise<IPaginateClient> {
+        const query: string = `query paginateRole($page: Int, $limit: Int, $search:String) { 
+            paginateRole(page: $page, limit: $limit, search: $search) { 
+                total, page, limit, items{id, name , permissions, readonly } 
+            } 
+        }`
+        const variables = {page, limit,search}
+        let data = await this.gqlClient.query(query, variables)
+        return data.paginateRole
+    }
+
+
+}
+
+export default RoleGqlProvider

package/src/providers/gql/UserGqlProvider.ts

@@ -0,0 +1,63 @@
+import type {IGqlClient, IPaginateClient} from '@drax/common-front'
+import type {IUserProvider} from "../../interfaces/IUserProvider";
+import type {IUser, IUserCreate, IUserPassword, IUserUpdate} from "../../interfaces/IUser";
+
+class UserGqlProvider implements IUserProvider {
+
+    gqlClient: IGqlClient
+
+    constructor(gqlClient: IGqlClient) {
+        this.gqlClient = gqlClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.gqlClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.gqlClient.removeHeader('Authorization')
+    }
+
+    async createUser(payload: IUserCreate): Promise<IUser> {
+        const query: string = `mutation createUser($input: UserCreateInput) { createUser(input: $input) {  
+        id username name email phone active role{id name}  } }`
+        const variables = {input: payload}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createUser
+    }
+
+    async editUser(id: string, payload: IUserUpdate): Promise<IUser> {
+        const query: string = `mutation updateUser($id: ID!, $input: UserUpdateInput) { updateUser(id: $id, input: $input) {  
+        id username name email phone active role{id name}  } }`
+        const variables = {id, input: payload}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createUser
+    }
+
+    async changeUserPassword(userId: string, newPassword: string): Promise<boolean> {
+        const query: string = `mutation changeUserPassword($userId: ID!, $newPassword: String!) { changeUserPassword(userId:$userId, newPassword: $newPassword)   }`
+        const variables = {userId, newPassword}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.changeUserPassword
+    }
+
+    async deleteUser(id: string): Promise<any> {
+        const query: string = `mutation deleteUser($id: ID!) { deleteUser(id: $id) }`
+        const variables = {id: id}
+        let data = await this.gqlClient.mutation(query, variables)
+        return data.createUser
+    }
+
+    async paginateUser(page: number, limit: number, search:string = ""): Promise<IPaginateClient> {
+        const query: string = `query paginateUser($page: Int, $limit: Int, $search:String) { 
+            paginateUser(page: $page, limit: $limit, search: $search) { 
+                total, page, limit, items{ id, name username, email, phone, active, role{id, name} } 
+            } 
+        }`
+        const variables = {page, limit, search}
+        let data = await this.gqlClient.query(query, variables)
+        return data.paginateUser
+    }
+}
+
+export default UserGqlProvider

package/src/providers/rest/AuthRestProvider.ts

@@ -0,0 +1,51 @@
+
+import type {IHttpClient} from '@drax/common-front'
+import type {IAuthProvider} from "../../interfaces/IAuthProvider";
+import type {IAuthUser} from "../../interfaces/IAuthUser";
+import type {ILoginResponse} from "../../interfaces/ILoginResponse";
+
+
+class AuthRestProvider implements IAuthProvider {
+
+    httpClient: IHttpClient
+
+    constructor(httpClient: IHttpClient) {
+        this.httpClient = httpClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.httpClient.removeHeader('Authorization')
+    }
+
+    async login(username: string, password: string): Promise<ILoginResponse> {
+            const url = '/api/auth'
+            const data = {username, password}
+            let {accessToken} = await this.httpClient.post(url, data) as ILoginResponse
+            this.setHttpClientToken(accessToken)
+            return {accessToken}
+    }
+
+    logout(): void {
+        this.removeHttpClientToken()
+    }
+
+    async me(): Promise<IAuthUser> {
+            const url = '/api/me'
+            let r = await this.httpClient.get(url) as IAuthUser
+            return r
+    }
+
+    async changeOwnPassword(currentPassword: string, newPassword: string): Promise<boolean> {
+        const url = '/api/password'
+        const data = {currentPassword, newPassword}
+        let r = await this.httpClient.post(url, data)
+        return /true/i.test(r as string)
+    }
+}
+
+export default AuthRestProvider
+export {AuthRestProvider}

package/src/providers/rest/RoleRestProvider.ts

@@ -0,0 +1,61 @@
+import type {IHttpClient, IPaginateClient} from '@drax/common-front'
+import type {IRoleProvider} from "../../interfaces/IRoleProvider.ts";
+import type {IRole} from "../../interfaces/IRole";
+
+class RoleRestProvider implements IRoleProvider {
+
+    httpClient: IHttpClient
+
+    constructor(httpClient: IHttpClient) {
+        this.httpClient = httpClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.httpClient.removeHeader('Authorization')
+    }
+
+    async fetchPermissions(): Promise<any> {
+        const url = '/api/permissions'
+        let permissions = await this.httpClient.get(url)
+        return permissions
+    }
+
+    async fetchRole(): Promise<any> {
+        const url = '/api/roles/all'
+        let role = await this.httpClient.get(url)
+        return role
+    }
+
+    async createRole(data: IRole): Promise<any> {
+            const url = '/api/roles'
+            let role = await this.httpClient.post(url, data)
+            return role
+    }
+    async editRole(id: string, data: IRole): Promise<IRole> {
+        const url = '/api/roles/' + id
+        let user = await this.httpClient.put(url, data)
+        return user as IRole
+    }
+
+    async deleteRole(id: string): Promise<any> {
+        const url = '/api/roles/' + id
+        let user = await this.httpClient.delete(url)
+        return user
+    }
+
+    async paginateRole(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient> {
+        const url = '/api/roles'
+        const params = {page, limit, search}
+        let paginatedRoles = await this.httpClient.get(url, {params})
+        return paginatedRoles as IPaginateClient
+
+    }
+
+
+}
+
+export default RoleRestProvider

package/src/providers/rest/UserRestProvider.ts

@@ -0,0 +1,55 @@
+import type {IHttpClient, IPaginateClient} from '@drax/common-front'
+import type {IUserProvider} from "../../interfaces/IUserProvider.ts";
+import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser.ts";
+
+class UserRestProvider implements IUserProvider {
+
+    httpClient: IHttpClient
+
+    constructor(httpClient: IHttpClient) {
+        this.httpClient = httpClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.httpClient.removeHeader('Authorization')
+    }
+
+    async createUser(data: IUserCreate): Promise<IUser> {
+            const url = '/api/users'
+            let user = await this.httpClient.post(url, data)
+            return user as IUser
+    }
+
+    async editUser(id: string, data: IUserUpdate): Promise<IUser> {
+            const url = '/api/users/' + id
+            let user = await this.httpClient.put(url, data)
+            return user as IUser
+    }
+
+    async deleteUser(id: string): Promise<any> {
+            const url = '/api/users/' + id
+            let user = await this.httpClient.delete(url)
+            return user
+    }
+
+    async paginateUser(page: number = 1, limit: number = 5, search:string = ""): Promise<IPaginateClient> {
+            const url = '/api/users'
+            const params = {page, limit, search}
+            let paginatedUsers = await this.httpClient.get(url, {params})
+            return paginatedUsers as IPaginateClient
+
+    }
+
+    async changeUserPassword(userId: string, newPassword: string): Promise<boolean> {
+        const url = '/api/password/' + userId
+        const data = {userId, newPassword}
+        let r = await this.httpClient.post(url, data)
+        return /true/i.test(r as string)
+    }
+}
+
+export default UserRestProvider

package/src/system/AuthSystem.ts

@@ -0,0 +1,35 @@
+import type {IAuthProvider} from "../interfaces/IAuthProvider.ts";
+import type {IAuthUser} from "@/interfaces/IAuthUser";
+import type {ILoginResponse} from "@/interfaces/ILoginResponse";
+
+class AuthSystem {
+
+    _provider : IAuthProvider
+    prototype: string;
+    constructor(provider:IAuthProvider) {
+        this._provider = provider;
+        this.prototype = 'AuthSystem'
+    }
+
+    async login(username:string, password:string):Promise<ILoginResponse> {
+        const r = await this._provider.login(username, password)
+        return r
+    }
+
+    logout():void {
+        this._provider.logout()
+    }
+
+    async me():Promise<IAuthUser> {
+        const authUser: IAuthUser = await this._provider.me()
+        return authUser
+    }
+
+    async changeOwnPassword(currentPassword:string, newPassword:string):Promise<boolean> {
+        const result: boolean = await this._provider.changeOwnPassword(currentPassword,newPassword)
+        return result
+    }
+}
+
+export default AuthSystem
+export {AuthSystem}

package/src/system/RoleSystem.ts

@@ -0,0 +1,43 @@
+import type {IRoleProvider} from "@/interfaces/IRoleProvider";
+import type {IRole} from "@/interfaces/IRole";
+import type {IPaginateClient} from "@drax/common-front";
+
+
+class RoleSystem {
+
+    _provider: IRoleProvider
+    prototype: string;
+
+    constructor(provider: IRoleProvider) {
+        this._provider = provider;
+        this.prototype = 'RoleSystem'
+    }
+
+    fetchRole():Promise<any> {
+        return this._provider.fetchRole()
+    }
+
+    fetchPermissions():Promise<any> {
+        return this._provider.fetchPermissions()
+    }
+
+    async paginateRole(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient> {
+        return this._provider.paginateRole(page, perPage,search)
+    }
+
+    async createRole(userPayload: IRole):Promise<IRole> {
+        return this._provider.createRole(userPayload)
+    }
+
+    async editRole(id:string, userPayload: IRole):Promise<IRole> {
+        return this._provider.editRole(id, userPayload)
+    }
+
+    async deleteRole(id: string):Promise<any> {
+        return this._provider.deleteRole(id)
+    }
+
+}
+
+export default RoleSystem
+export {RoleSystem}

package/src/system/UserSystem.ts

@@ -0,0 +1,41 @@
+import type {IUserProvider} from "@/interfaces/IUserProvider";
+import type {IUser, IUserCreate, IUserUpdate} from "@/interfaces/IUser";
+import type {IPaginateClient} from "@drax/common-front";
+
+
+class UserSystem {
+
+    _provider: IUserProvider
+    prototype: string;
+
+    constructor(provider: IUserProvider) {
+        this._provider = provider;
+        this.prototype = 'UserSystem'
+    }
+
+    async paginateUser(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient> {
+        return this._provider.paginateUser(page, perPage, search)
+    }
+
+    async createUser(userPayload: IUserCreate):Promise<IUser> {
+        return this._provider.createUser(userPayload)
+    }
+
+    async editUser(id:string, userPayload: IUserUpdate):Promise<IUser> {
+        return this._provider.editUser(id, userPayload)
+    }
+
+    async changeUserPassword(userId:string, newPassword:string):Promise<boolean> {
+        console.log("UserSystem",userId, newPassword)
+        const result: boolean = await this._provider.changeUserPassword(userId,newPassword)
+        return result
+    }
+
+    async deleteUser(id: string):Promise<any> {
+        return this._provider.deleteUser(id)
+    }
+
+}
+
+export default UserSystem
+export {UserSystem}

package/src/assets/base.css

@@ -1,86 +0,0 @@
-/* color palette from <https://github.com/vuejs/theme> */
-:root {
-  --vt-c-white: #ffffff;
-  --vt-c-white-soft: #f8f8f8;
-  --vt-c-white-mute: #f2f2f2;
-
-  --vt-c-black: #181818;
-  --vt-c-black-soft: #222222;
-  --vt-c-black-mute: #282828;
-
-  --vt-c-indigo: #2c3e50;
-
-  --vt-c-divider-light-1: rgba(60, 60, 60, 0.29);
-  --vt-c-divider-light-2: rgba(60, 60, 60, 0.12);
-  --vt-c-divider-dark-1: rgba(84, 84, 84, 0.65);
-  --vt-c-divider-dark-2: rgba(84, 84, 84, 0.48);
-
-  --vt-c-text-light-1: var(--vt-c-indigo);
-  --vt-c-text-light-2: rgba(60, 60, 60, 0.66);
-  --vt-c-text-dark-1: var(--vt-c-white);
-  --vt-c-text-dark-2: rgba(235, 235, 235, 0.64);
-}
-
-/* semantic color variables for this project */
-:root {
-  --color-background: var(--vt-c-white);
-  --color-background-soft: var(--vt-c-white-soft);
-  --color-background-mute: var(--vt-c-white-mute);
-
-  --color-border: var(--vt-c-divider-light-2);
-  --color-border-hover: var(--vt-c-divider-light-1);
-
-  --color-heading: var(--vt-c-text-light-1);
-  --color-text: var(--vt-c-text-light-1);
-
-  --section-gap: 160px;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --color-background: var(--vt-c-black);
-    --color-background-soft: var(--vt-c-black-soft);
-    --color-background-mute: var(--vt-c-black-mute);
-
-    --color-border: var(--vt-c-divider-dark-2);
-    --color-border-hover: var(--vt-c-divider-dark-1);
-
-    --color-heading: var(--vt-c-text-dark-1);
-    --color-text: var(--vt-c-text-dark-2);
-  }
-}
-
-*,
-*::before,
-*::after {
-  box-sizing: border-box;
-  margin: 0;
-  font-weight: normal;
-}
-
-body {
-  min-height: 100vh;
-  color: var(--color-text);
-  background: var(--color-background);
-  transition:
-    color 0.5s,
-    background-color 0.5s;
-  line-height: 1.6;
-  font-family:
-    Inter,
-    -apple-system,
-    BlinkMacSystemFont,
-    'Segoe UI',
-    Roboto,
-    Oxygen,
-    Ubuntu,
-    Cantarell,
-    'Fira Sans',
-    'Droid Sans',
-    'Helvetica Neue',
-    sans-serif;
-  font-size: 15px;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}

package/src/assets/logo.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 261.76 226.69"><path d="M161.096.001l-30.225 52.351L100.647.001H-.005l130.877 226.688L261.749.001z" fill="#41b883"/><path d="M161.096.001l-30.225 52.351L100.647.001H52.346l78.526 136.01L209.398.001z" fill="#34495e"/></svg>

package/src/assets/main.css

@@ -1,35 +0,0 @@
-@import './base.css';
-
-#app {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  font-weight: normal;
-}
-
-a,
-.green {
-  text-decoration: none;
-  color: hsla(160, 100%, 37%, 1);
-  transition: 0.4s;
-  padding: 3px;
-}
-
-@media (hover: hover) {
-  a:hover {
-    background-color: hsla(160, 100%, 37%, 0.2);
-  }
-}
-
-@media (min-width: 1024px) {
-  body {
-    display: flex;
-    place-items: center;
-  }
-
-  #app {
-    display: grid;
-    grid-template-columns: 1fr 1fr;
-    padding: 0 2rem;
-  }
-}

package/src/components/HelloWorld.vue

@@ -1,41 +0,0 @@
-<script setup lang="ts">
-defineProps<{
-  msg: string
-}>()
-</script>
-
-<template>
-  <div class="greetings">
-    <h1 class="green">{{ msg }}</h1>
-    <h3>
-      You’ve successfully created a project with
-      <a href="https://vitejs.dev/" target="_blank" rel="noopener">Vite</a> +
-      <a href="https://vuejs.org/" target="_blank" rel="noopener">Vue 3</a>.
-    </h3>
-  </div>
-</template>
-
-<style scoped>
-h1 {
-  font-weight: 500;
-  font-size: 2.6rem;
-  position: relative;
-  top: -10px;
-}
-
-h3 {
-  font-size: 1.2rem;
-}
-
-.greetings h1,
-.greetings h3 {
-  text-align: center;
-}
-
-@media (min-width: 1024px) {
-  .greetings h1,
-  .greetings h3 {
-    text-align: left;
-  }
-}
-</style>

package/src/components/IdentityLogin/IdentityLogin.vue

@@ -1,82 +0,0 @@
-<script setup lang="ts">
-import { ref, computed, defineProps } from 'vue'
-import {useAuthStore} from "../../stores/auth/AuthStore.js";
-
-const {getAuthSystem} = useAuthStore()
-
-// Define props for customizing labels, title, and button text
-const props = defineProps({
-  title: {
-    type: String,
-    default: 'Login'
-  },
-  usernameLabel: {
-    type: String,
-    default: 'Username'
-  },
-  passwordLabel: {
-    type: String,
-    default: 'Password'
-  },
-  buttonText: {
-    type: String,
-    default: 'Login'
-  }
-})
-
-// Define reactive variables for form inputs
-const username = ref('')
-const password = ref('')
-
-// Compute whether the form is valid (both username and password are not empty)
-const isFormValid = computed(() => username.value.trim() !== '' && password.value.trim() !== '')
-
-// Function to handle form submission
-const submitForm = () => {
-  console.log('Submitting:', { username: username.value, password: password.value })
-  getAuthSystem?.login(username.value, password.value)
-  // Here you would typically send the data to your backend
-}
-</script>
-
-<template>
-  <v-container>
-    <v-row justify="center">
-      <v-col cols="12" sm="8" md="6" lg="5" xl="4" >
-        <v-form @submit.prevent="submitForm">
-          <v-card variant="tonal">
-            <v-card-title>{{ props.title }}</v-card-title>
-            <v-card-text>
-              <v-text-field
-                id="username-input"
-                v-model="username"
-                :label="props.usernameLabel"
-                required
-              ></v-text-field>
-              <v-text-field
-                id="password-input"
-                v-model="password"
-                :label="props.passwordLabel"
-                type="password"
-                required
-              ></v-text-field>
-            </v-card-text>
-            <v-card-actions>
-              <v-spacer></v-spacer>
-              <v-btn
-                id="submit-button"
-                type="submit"
-                color="primary"
-                :disabled="!isFormValid"
-              >{{ props.buttonText }}</v-btn>
-            </v-card-actions>
-          </v-card>
-        </v-form>
-      </v-col>
-    </v-row>
-  </v-container>
-</template>
-
-<style scoped lang="sass">
-// Your styles here
-</style>

package/src/components/__tests__/IdentityLogin.spec.ts

@@ -1,11 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-import { mount } from '@vue/test-utils'
-import IdentityLogin from '../IdentityLogin/IdentityLogin.vue'
-
-describe('IdentityLogin', () => {
-  it('renders properly', () => {
-    const wrapper = mount(IdentityLogin, { props: { msg: 'Hello Vitest' } })
-    expect(wrapper.text()).toContain('Hello Vitest')
-  })
-})