feat: frontend

ordr-ui/app/providers/AuthenticationProvider.ts

@@ -0,0 +1,27 @@
+import { create } from 'zustand'
+import { UserResponse } from '../client/response'
+import { GetCurrentUser, SetUserName } from '../client/controllers'
+
+export type UserActions = {
+	sync: () => Promise<UserResponse | undefined>
+	updateName: (name: string) => Promise<void>
+}
+
+export const useCurrentAuthenticatedUserStore = create<UserResponse & UserActions>((set) => ({
+	Id: -1,
+	Name: '',
+	JobPosition: '',
+	Active: false,
+	Admin: false,
+	sync: async () => {
+		const authUser = await GetCurrentUser()
+		set((state) => ({
+			...authUser,
+			...state
+		}))
+		return authUser 
+	},
+	updateName: async (name: string) => {
+		await SetUserName(name)
+	}
+}))

ordr-ui/app/providers/ItemsProvider.ts

@@ -0,0 +1,188 @@
+import { create } from 'zustand'
+import { ItemPriceResponse, OrderItemPriceResponse, OrderFilledResponse } from '../client/response'
+import * as ItemController from '../client/controllers/ItemController'
+import { CreateItemQuery } from '../client/queries/CreateItemQuery'
+import { SetItemPriceQuery } from '../client/queries/SetItemPriceQuery'
+import { blob } from 'stream/consumers'
+
+export type ItemData = {
+	items: ItemPriceResponse[],
+	orderItems: OrderItemPriceResponse[]
+}
+
+export type ItemActions = {
+	sync: () => Promise<void>
+	createItem: (itemName: string, inSeason: boolean, itemPrice: number) => Promise<ItemPriceResponse>
+	setItemPrice: (itemId: number, price: number) => Promise<void>
+	getCurrentPrice: (itemId: number) => Promise<ItemPriceResponse>
+	addItemToOrder: (itemId: number, orderId: number, quantity: number) => Promise<OrderItemPriceResponse>
+	getOrderItems: (orderId: number) => Promise<OrderItemPriceResponse[]>
+	setItemMade: (orderId: number, itemId: number, made: number) => Promise<OrderFilledResponse>
+	setItemQuantity: (orderId: number, itemId: number, quantity: number) => Promise<OrderFilledResponse>
+	deleteOrderItem: (orderId: number, itemId: number) => Promise<void>
+	deleteItem: (itemId: number) => Promise<void>
+}
+
+export const useItemStore = create<ItemData & ItemActions>((set, get) => ({
+	items: [],
+	orderItems: [],
+	sync: async (): Promise<void> => {
+		const itemPrices = await ItemController.GetItems()
+		set((state) => ({
+			...state,
+			items: itemPrices
+		}))
+	},
+	createItem: async (itemName: string, inSeason: boolean, itemPrice: number): Promise<ItemPriceResponse> => {
+		const itemQuery: CreateItemQuery = {
+			item_name: itemName,
+			in_season: inSeason ? "1" : "0",
+			item_price: itemPrice.toString()
+		}
+
+		const itemResponse = await ItemController.CreateItem(itemQuery)
+		set((state) => ({
+			...state,
+			items: [...state.items, itemResponse]
+		}))
+		return itemResponse
+	},
+	setItemPrice: async (itemId: number, price: number): Promise<void> => {
+		const itemPriceQuery: SetItemPriceQuery = {
+			item_id: itemId.toString(),
+			item_price: price.toString()
+		}
+
+		await ItemController.SetItemPrice(itemPriceQuery)
+
+		set((state) => {
+			const item = state.items.filter((i) => i.ItemId === itemId)[0]
+			let itemsWithoutItem = state.items.filter((i) => i.ItemId !== itemId)
+			item.ItemPrice = price
+			if(!Array.isArray(itemsWithoutItem))
+				itemsWithoutItem = [itemsWithoutItem]
+			return {
+				...state,
+				items: [...itemsWithoutItem, item].sort((a,b) => {
+					if(a.InSeason && !b.InSeason)
+						return 1
+					if(!a.InSeason && b.InSeason)
+						return -1
+					return a.ItemId - b.ItemId
+				})
+			}
+		})
+	},
+	getCurrentPrice: async (itemId: number): Promise<ItemPriceResponse> => {
+		const store = get()
+
+		const priceObjectArray = store.items.filter((i: ItemPriceResponse) => i.ItemId === itemId)
+
+		if(priceObjectArray.length > 0) {
+			return priceObjectArray[0]
+		}
+		
+		const resp = await ItemController.GetCurrentPrice({item_id: itemId.toString()})
+
+		set((state) => ({
+			...state,
+			items: [...state.items, resp]
+		}))
+		return resp
+	},
+	addItemToOrder: async (itemId: number, orderId: number, quantity: number): Promise<OrderItemPriceResponse> => {
+		const resp = await ItemController.AddItemToOrder({item_id: itemId.toString(), order_id: orderId.toString(), quantity: quantity.toString()})
+
+		set((state) => ({
+			...state,
+			orderItems: [...state.orderItems, resp]
+		}))
+
+		return resp
+	},
+	getOrderItems: async (orderId: number): Promise<OrderItemPriceResponse[]> => {
+		const state = get()
+		
+		const fetchedOrderItems = state.orderItems
+		
+		const orderOrderItems = fetchedOrderItems.filter((i) => i.OrderId === orderId)
+
+		if(orderOrderItems.length > 0) {
+			return orderOrderItems
+		}
+		
+		const resp = await ItemController.GetOrderItems({order_id: orderId.toString()})
+		
+		set((state) => ({
+			orderItems: [...state.orderItems, ...resp]
+		}))
+
+		return resp
+	},
+	setItemMade: async (orderId: number, itemId: number, made: number): Promise<OrderFilledResponse> => {
+		const order_filled: OrderFilledResponse = await ItemController.SetItemMade({
+			order_id: orderId,
+			item_id: itemId,
+			made: made
+		})
+
+		set((state) => {
+			// TODO: Update order filled once order store is made
+			const orderItem = state.orderItems.filter((oi) => oi.ItemId === itemId && oi.OrderId === orderId)[0]
+			const orderItemsWithoutOrderItem = state.orderItems.filter((oi) => oi.ItemId !== itemId || oi.OrderId !== orderId)
+			orderItem.Made = made
+
+			return {
+				...state,
+				orderItems: [...orderItemsWithoutOrderItem, orderItem]
+			}
+		})
+
+		return order_filled
+	},
+	setItemQuantity: async (orderId: number, itemId: number, quantity: number): Promise<OrderFilledResponse> => {
+		const order_filled: OrderFilledResponse = await ItemController.SetItemQuantity({
+			order_id: orderId,
+			item_id: itemId,
+			quantity: quantity
+		})
+
+		set((state) => {
+			// TODO: Update order filled once order store is made
+			const orderItem = state.orderItems.filter((oi) => oi.ItemId === itemId && oi.OrderId === orderId)[0]
+			const orderItemsWithoutOrderItem = state.orderItems.filter((oi) => oi.ItemId !== itemId || oi.OrderId !== orderId)
+			
+			orderItem.Quantity = quantity
+
+			return {
+				...state,
+				orderItems: [...orderItemsWithoutOrderItem, orderItem]
+			}
+		})
+
+		return order_filled
+
+	},
+	deleteOrderItem: async (orderId: number, itemId: number): Promise<void> => {
+		await ItemController.DeleteOrderItem({order_id: orderId, item_id: itemId})
+
+		set((state) => ({
+			...state,
+			orderItems: [...(state.orderItems.filter((i) => i.OrderId !== orderId || i.ItemId !== itemId))]
+		}))
+	},
+	deleteItem: async (itemId: number): Promise<void> => {
+		await ItemController.DeleteItem(itemId)
+
+		set((state) => {
+			const itemsWithoutItem = state.items.filter((i) => i.ItemId !== itemId)
+			const orderItemsWithoutItem = state.orderItems.filter((i) => i.ItemId !== itemId)
+
+			return {
+				...state,
+				items: itemsWithoutItem,
+				orderItems: orderItemsWithoutItem
+			}
+		})
+	}
+}))

ordr-ui/app/providers/OrderProvider.ts

@@ -0,0 +1,43 @@
+import { create } from 'zustand'
+import { OrderResponse } from '../client/response'
+import { OrderTableQuery } from '../client/request/GetOrderTableRequest'
+import * as OrderController from '../client/controllers/OrderController'
+
+type OrderData = {
+	orders: OrderResponse[]
+}
+
+type OrderActions = {
+	sync: (page: number, filter: number, searchParams: OrderTableQuery) => Promise<OrderResponse[]>
+	createOrder: (orderer: string, dateDue: string) => Promise<OrderResponse>
+	getOrderById: (orderId: number) => Promise<OrderResponse>
+	deleteOrder: (orderId: number) => Promise<void>
+}
+
+export const useOrderStore = create<OrderData & OrderActions>((set, get) => ({
+	orders: [],
+	sync: async (page: number, filter: number, searchParams: OrderTableQuery): Promise<OrderResponse[]> => {
+		const resp = await OrderController.GetOrderTable(page, filter, searchParams)
+		set((state) => ({
+			...state,
+			orders: resp
+		}))
+		return resp
+	},
+	createOrder: async (orderer: string, dateDue: string): Promise<OrderResponse> => {
+		const resp = await OrderController.CreateOrder(orderer, dateDue)
+		console.log(resp)
+		set((state) => ({
+			...state,
+			orders: [...state.orders, resp]
+		}))
+		console.log(get().orders)
+		return resp
+	},
+	getOrderById: async (orderId: number): Promise<OrderResponse> => {
+		return await OrderController.GetOrderById(orderId)
+	},
+	deleteOrder: async (orderId): Promise<void> => {
+		await OrderController.DeleteOrder(orderId)
+	}
+}))

ordr-ui/app/providers/UsersProvider.ts

@@ -0,0 +1,113 @@
+import { create } from 'zustand'
+import { UserResponse } from '../client/response'
+import { GetUserTable, SetUserPosition, PromoteUser, DemoteUser, DeactivateUser, CreatePosition, ActivateUser } from '../client/controllers'
+type UserData = {
+	tableUsers: UserResponse[]
+}
+
+type UsersActions = {
+	sync: (page: number) => Promise<UserResponse[]>
+	setUserPosition: (userId: number, positionName: string) => Promise<void>
+	promoteUser: (userId: number) => Promise<void>
+	demoteUser: (userId: number) => Promise<void>
+	deactivateUser: (userId: number) => Promise<void>
+	activateUser: (userId: number) => Promise<void>
+	createPosition: (positionName: string) => Promise<void>
+}
+
+export const useUserStore = create<UserData & UsersActions>((set) => ({
+	sync: async (page: number): Promise<UserResponse[]> => {
+		const users_in_page = await GetUserTable(page)
+		set((state) => ({
+			... state,
+			tableUsers: users_in_page,
+		}))
+		return users_in_page
+	},
+	tableUsers: [] as UserResponse[],
+	setUserPosition: async (userId, positionName): Promise<void> => {
+		await SetUserPosition(userId, positionName)
+		
+		
+		set((state) => {
+			const match_user = state.tableUsers.filter((u) => u.Id === userId)[0]
+			match_user.JobPosition = positionName
+			return {
+				... state,
+				tableUsers: [...state.tableUsers, match_user]
+			}
+		})
+	},
+	promoteUser: async (userId: number): Promise<void> => {
+		await PromoteUser(userId)
+		set((state) => {
+			const users = state.tableUsers.filter((u) => u.Id === userId)
+			if(users.length > 0)
+			{
+				const user = users[0]
+				const tableUsersWithoutUser = state.tableUsers.filter((u) => u.Id !== userId)
+				user.Admin = true
+				return {
+					...state,
+					tableUsers: [...tableUsersWithoutUser, user]
+				}
+			}
+			return state
+		})
+	},
+	demoteUser: async (userId: number): Promise<void> => {
+		await DemoteUser(userId)
+		set((state) => {
+			const users = state.tableUsers.filter((u) => u.Id === userId)
+			if(users.length > 0)
+			{
+				const user = users[0]
+				const tableUsersWithoutUser = state.tableUsers.filter((u) => u.Id !== userId)
+				user.Admin = false
+				return {
+					...state,
+					tableUsers: [...tableUsersWithoutUser, user]
+				}
+			}
+			return state
+		})
+	},
+	deactivateUser: async (userId: number): Promise<void> => {
+		await DeactivateUser(userId)
+
+		set((state) => {
+			const users = state.tableUsers.filter((u) => u.Id === userId)
+			if(users.length > 0)
+			{
+				const user = users[0]
+				const tableUsersWithoutUser = state.tableUsers.filter((u) => u.Id !== userId)
+				user.Active = false
+				return {
+					...state,
+					tableUsers: [...tableUsersWithoutUser, user]
+				}
+			}
+			return state
+		})
+	},
+	activateUser: async (userId: number): Promise<void> => {
+		await ActivateUser(userId)
+		set((state) => {
+			const users = state.tableUsers.filter((u) => u.Id === userId)
+			if(users.length > 0)
+			{
+				const user = users[0]
+				const tableUsersWithoutUser = state.tableUsers.filter((u) => u.Id !== userId)
+				user.Active = true
+				return {
+					...state,
+					tableUsers: [...tableUsersWithoutUser, user]
+				}
+			}
+			return state
+		})
+	},
+	createPosition: async (positionName: string): Promise<void> => {
+		await CreatePosition(positionName)
+	}
+}))

ordr-ui/app/providers/index.ts

@@ -0,0 +1 @@
+export * from './AuthenticationProvider'