Merge remote-tracking branch 'origin/next' into next

src/boot/login.ts

@@ -6,19 +6,21 @@ import { StateInterface } from 'src/store';
 export default boot<Store<StateInterface>>(({ router, store }) => {
   router.beforeEach((to, from, next) => {
     store.dispatch('user/loadFromLocalStorage').then(() => {
-      const permissions = store.getters['user/permissions'];
+      const user: User = store.getters['user/user'];
-      console.log('login_boot', permissions);
+      let permissions: string[] = [];
+      user.roles.forEach(role => {
+        permissions = permissions.concat(role.permissions)
+      });
+
       if (
         to.matched.some((record: RouteRecord) => {
           // permissions is set AND has NO matching permission
           return (
-            permissions in record.meta &&
+            "permissions" in record.meta &&
-            !(
+            (
-              (
+              record.meta.permissions.filter((value: string) =>
-                record.meta.permissions.filter((value: string) =>
+                permissions.includes(value)
-                  permissions.includes(value)
+              ).length == 0
-                ).length > 0
-              )
             )
           );
         })

src/flaschengeist.d.ts

@@ -1,31 +1,51 @@
-interface Session {
+declare namespace FG {
-  user: User;
+	interface Event {
-  expires: Date;
+		id: number;
-  token: string;
+		begin: Date;
-  lifetime: number;
+		end?: Date;
-  browser: string;
+		description: string;
-  platform: string;
+		kind: EventKind;
-}
+		slots: Array<EventSlot>;
-interface User {
+	}
-  roles: Array<Role>;
+	interface EventKind {
-  userid: string;
+		id: number;
-  display_name: string;
+		name: string;
-  firstname: string;
+	}
-  lastname: string;
+	interface EventSlot {
-  mail: string;
+		id: number;
-}
+		start: Date;
-interface Permission {
+		end?: any;
-  id: number;
+		slots: Array<any>;
-  name: string;
+	}
-}
+	interface Job {
-interface Role {
+		userid: string;
-  permissions: Array<Permission>;
+		value: number;
-  id: number;
+	}
-  name: string;
+	type JobKind = string;
-}
+	interface JobSlot {
-interface UserAttribute {
+		id: number;
-  id: number;
+		needed_persons: number;
-  user: number;
+		kind: JobKind;
-  name: string;
+		jobs: Array<Job>;
-  value: string;
+	}
+	interface User {
+		userid: string;
+		display_name: string;
+		firstname: string;
+		lastname: string;
+		mail: string;
+		roles: Array<Role>;
+	}
+	interface Session {
+		expires: Date;
+		token: string;
+		lifetime: number;
+		browser: string;
+		platform: string;
+	}
+	type Permission = string;
+	interface Role {
+		name: string;
+		permissions: Array<Permission>;
+	}
 }

src/plugins/user/pages/User.vue

@@ -10,17 +10,17 @@
         height=""
       >
         <q-card-section>
-          Name: {{ userSession.user.firstname }} {{ userSession.user.lastname }}<br />
+          Name: {{ userObj.firstname }} {{ userObj.lastname }}<br />
-          E-Mail: {{ userSession.user.mail }}<br />
+          E-Mail: {{ userObj.mail }}<br />
           Roles:
           <ul
-            v-for="role in userSession.user.roles"
+            v-for="role in userObj.roles"
             v-bind:key="role"
           >
             <li>{{ role }}</li>
           </ul>
           <br />
-          Token expires: {{ userSession.expires }}
+          Token expires: {{ sessionObj.expires }}
         </q-card-section>
       </q-card>
     </q-page>
@@ -36,16 +36,16 @@ import { mainLink } from '../plugin';
 export default defineComponent({
   // name: 'PageName'
   setup(_, { root }) {
-    const userPermissions = computed(
+    const userObj = computed(
-      () => <UserStateInterface>root.$store.getters['user/permissions']
+      () => <UserStateInterface>root.$store.getters['user/user']
     );
-    const userSession = computed(
+    const sessionObj = computed(
       () => <UserStateInterface>root.$store.getters['user/session']
     );
     const checkMain = computed(() => {
       return mainLink.name == root.$route.name;
     });
-    return { userPermissions, userSession, checkMain };
+    return { userObj, sessionObj, checkMain };
   }
 });
 </script>

src/plugins/user/store/user.ts

@@ -11,57 +11,56 @@ export interface UserStateInterface extends LoginResponse {
 }
 
 export interface LoginResponse {
-  permissions: string[];
+  user: FG.User;
-  session: Session;
+  session: FG.Session;
 }
 
 const state: UserStateInterface = {
-  permissions: [],
+  user: {
+    display_name: '',
+    firstname: '',
+    lastname: '',
+    mail: '',
+    roles: [],
+    userid: ''
+  },
   session: {
     browser: '',
     expires: new Date(),
     lifetime: -1,
     platform: '',
-    token: '',
+    token: ''
-    user: {
-      display_name: '',
-      firstname: '',
-      lastname: '',
-      mail: '',
-      roles: [],
-      userid: ''
-    }
   },
   loginLoading: false
 };
 
 const mutations: MutationTree<UserStateInterface> = {
-  setPermissions(state, data: []) {
+  setUser (state, data: FG.User) {
-    state.permissions = data;
+    state.user = data;
   },
-  setSession(state, data: Session) {
+  setSession (state, data: FG.Session) {
     state.session = data;
   },
-  setLoginLoading(state, data: boolean) {
+  setLoginLoading (state, data: boolean) {
     state.loginLoading = data;
   },
-  showState(state) {
+  showState (state) {
     console.log(state);
   }
 };
 
 const actions: ActionTree<UserStateInterface, StateInterface> = {
-  login({ commit }, data: LoginData) {
+  login ({ commit }, data: LoginData) {
     commit('setLoginLoading', true);
     Loading.show({ message: 'Du wirst eingeloggt' });
     void axios
       .post('/auth', data)
       .then((response: AxiosResponse<LoginResponse>) => {
-        commit('setPermissions', response.data.permissions);
+        commit('setUser', response.data.user);
         console.log('saved permisisons');
         commit('setSession', response.data.session);
         commit('showState');
-        LocalStorage.set('permissions', response.data.permissions);
+        LocalStorage.set('user', response.data.user);
         LocalStorage.set('session', response.data.session);
 
         void Router.push({ name: 'user' });
@@ -74,10 +73,17 @@ const actions: ActionTree<UserStateInterface, StateInterface> = {
         Loading.hide();
       });
   },
-  logout({ commit }, token) {
+  logout ({ commit }, token) {
     void axios.delete(`/auth/${token}`).then(() => {
-      commit('setPermissions', []);
+      commit('setUser', {
-      commit('setToken', {
+        display_name: '',
+        firstname: '',
+        lastname: '',
+        mail: '',
+        roles: [],
+        userid: ''
+      });
+      commit('setSession', {
         browser: '',
         expires: '',
         lifetime: '',
@@ -86,39 +92,46 @@ const actions: ActionTree<UserStateInterface, StateInterface> = {
       });
     });
   },
-  loadFromLocalStorage({ commit }) {
+  loadFromLocalStorage ({ commit }) {
     console.log('load from store');
-    let data = LocalStorage.getItem('permissions');
+    let data = LocalStorage.getItem('user');
-    commit('setPermissions', data ? data : []);
+    commit('setUser', data ? data : {
+      display_name: '',
+      firstname: '',
+      lastname: '',
+      mail: '',
+      roles: [],
+      userid: ''
+    });
     data = LocalStorage.getItem('session');
     commit(
       'setSession',
       data
         ? data
         : {
-            browser: '',
+          browser: '',
-            expires: new Date(),
+          expires: new Date(),
-            lifetime: -1,
+          lifetime: -1,
-            platform: '',
+          platform: '',
-            token: ''
+          token: ''
-          }
+        }
     );
     commit('showState');
   }
 };
 
 const getters: GetterTree<UserStateInterface, StateInterface> = {
-  permissions({ permissions }) {
+  user ({ user }) {
-    return permissions;
+    return user;
   },
-  session({ session }) {
+  displayName ({ user }) {
+    return user.display_name;
+  },
+  session ({ session }) {
     return session;
   },
-  loginLoading({ loginLoading }) {
+  loginLoading ({ loginLoading }) {
     return loginLoading;
-  },
-  displayName({ session: { user } }) {
-    return `${user.firstname} ${user.lastname}`;
   }
 };