gsadmin/DynamoDNS
1
0
Fork 0
mirror of https://github.com/freedbygrace/DynamoDNS.git synced 2026-08-28 03:07:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove group management functionality

Browse Source 
Replit-Commit-Author: Agent
Replit-Commit-Session-Id: 9111ef36-26c8-4085-84ca-a35dc1fec1b5
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/7083d608-d6d3-4a6a-9a27-6286c5109627/aa864d33-76c2-47e9-866b-42e52da4b7cf.jpg
This commit is contained in:
alphaeusmote
2025-04-11 16:06:28 +00:00
parent 8f545a41f7 0520587236
commit ac6e5f7941
2 changed files with 6 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/routes.ts
+2 -136
View File
@@ -909,143 +909,9 @@ export async function registerRoutes(app: Express): Promise<Server> {
} }
}); });
// Groups // Groups functionality has been removed
app.get("/api/groups", requireRole(["admin", "manager"]), async (req, res) => {
try {
const groups = await storage.getGroups();
res.json(groups);
} catch (error) {
console.error("Error fetching groups:", error);
res.status(500).json({ message: "Internal server error" });
}
});
app.get("/api/groups/:id", requireRole(["admin", "manager"]), async (req, res) => { // Group Members endpoints have been removed
try {
const id = req.params.id;
const group = await storage.getGroup(id);
if (!group) {
return res.status(404).json({ message: "Group not found" });
}
res.json(group);
} catch (error) {
console.error("Error fetching group:", error);
res.status(500).json({ message: "Internal server error" });
}
});
app.get("/api/groups/:id/members", requireRole(["admin", "manager"]), async (req, res) => {
try {
const id = req.params.id;
const members = await storage.getGroupMembers(id);
res.json(members);
} catch (error) {
console.error("Error fetching group members:", error);
res.status(500).json({ message: "Internal server error" });
}
});
app.post("/api/groups", requireRole(["admin", "manager"]), async (req, res) => {
try {
const validatedData = insertGroupSchema.parse({
...req.body,
createdBy: req.user?.id
});
const group = await storage.createGroup(validatedData);
res.status(201).json(group);
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({ message: "Validation error", errors: error.errors });
} else {
console.error("Error creating group:", error);
res.status(500).json({ message: "Internal server error" });
}
}
});
app.put("/api/groups/:id", requireRole(["admin", "manager"]), async (req, res) => {
try {
const id = req.params.id;
const validatedData = insertGroupSchema.partial().parse(req.body);
const updatedGroup = await storage.updateGroup(id, validatedData);
if (!updatedGroup) {
return res.status(404).json({ message: "Group not found" });
}
res.json(updatedGroup);
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({ message: "Validation error", errors: error.errors });
} else {
console.error("Error updating group:", error);
res.status(500).json({ message: "Internal server error" });
}
}
});
app.delete("/api/groups/:id", requireRole(["admin", "manager"]), async (req, res) => {
try {
const id = req.params.id;
const deleted = await storage.deleteGroup(id);
if (!deleted) {
return res.status(404).json({ message: "Group not found" });
}
res.status(204).end();
} catch (error) {
console.error("Error deleting group:", error);
res.status(500).json({ message: "Internal server error" });
}
});
// Group Members
app.post("/api/group-members", requireRole(["admin", "manager"]), async (req, res) => {
try {
// Validate member type
const memberTypeValidator = z.enum(memberTypes);
// Extend schema with validation
const schema = insertGroupMemberSchema.extend({
memberType: memberTypeValidator
});
const validatedData = schema.parse({
...req.body,
addedBy: req.user?.id
});
const member = await storage.addGroupMember(validatedData);
res.status(201).json(member);
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({ message: "Validation error", errors: error.errors });
} else {
console.error("Error adding group member:", error);
res.status(500).json({ message: "Internal server error" });
}
}
});
app.delete("/api/group-members/:id", requireRole(["admin", "manager"]), async (req, res) => {
try {
const id = req.params.id;
const deleted = await storage.removeGroupMember(id);
if (!deleted) {
return res.status(404).json({ message: "Group member not found" });
}
res.status(204).end();
} catch (error) {
console.error("Error removing group member:", error);
res.status(500).json({ message: "Internal server error" });
}
});
// API Tokens // API Tokens
app.get("/api/api-tokens", requireRole(["admin", "manager"]), async (req, res) => { app.get("/api/api-tokens", requireRole(["admin", "manager"]), async (req, res) => {
server/storage.ts
+4 -77
View File
@@ -9,8 +9,6 @@ import {
type Webhook, type InsertWebhook, type Webhook, type InsertWebhook,
type WebhookDeliveryLog, type InsertWebhookDeliveryLog, type WebhookDeliveryLog, type InsertWebhookDeliveryLog,
type DnsMetric, type InsertDnsMetric, type DnsMetric, type InsertDnsMetric,
type Group, type InsertGroup,
type GroupMember, type InsertGroupMember,
type MemberType type MemberType
} from "@shared/schema"; } from "@shared/schema";
import session from "express-session"; import session from "express-session";
@@ -32,15 +30,7 @@ export interface IStorage {
updateOrganization(id: string, org: Partial<InsertOrganization>): Promise<Organization | undefined>; updateOrganization(id: string, org: Partial<InsertOrganization>): Promise<Organization | undefined>;
deleteOrganization(id: string): Promise<boolean>; deleteOrganization(id: string): Promise<boolean>;
// Group management // Group management has been removed
getGroup(id: string): Promise<Group | undefined>;
getGroups(): Promise<Group[]>;
getGroupMembers(groupId: string): Promise<GroupMember[]>;
createGroup(group: InsertGroup): Promise<Group>;
updateGroup(id: string, group: Partial<InsertGroup>): Promise<Group | undefined>;
deleteGroup(id: string): Promise<boolean>;
addGroupMember(member: InsertGroupMember): Promise<GroupMember>;
removeGroupMember(id: string): Promise<boolean>;
// Domain management // Domain management
getDomain(id: string): Promise<Domain | undefined>; getDomain(id: string): Promise<Domain | undefined>;
@@ -112,8 +102,7 @@ export class MemStorage implements IStorage {
private webhooksMap: Map<number, Webhook>; private webhooksMap: Map<number, Webhook>;
private webhookDeliveryLogsMap: Map<number, WebhookDeliveryLog>; private webhookDeliveryLogsMap: Map<number, WebhookDeliveryLog>;
private metricsMap: Map<number, DnsMetric>; private metricsMap: Map<number, DnsMetric>;
private groupsMap: Map<number, Group>; // Group maps have been removed
private groupMembersMap: Map<number, GroupMember>;
// Counters for IDs // Counters for IDs
private userIdCounter: number; private userIdCounter: number;
@@ -126,8 +115,7 @@ export class MemStorage implements IStorage {
private webhookIdCounter: number; private webhookIdCounter: number;
private webhookDeliveryLogIdCounter: number; private webhookDeliveryLogIdCounter: number;
private metricIdCounter: number; private metricIdCounter: number;
private groupIdCounter: number; // Group counters have been removed
private groupMemberIdCounter: number;
public sessionStore: any; public sessionStore: any;
@@ -322,68 +310,7 @@ export class MemStorage implements IStorage {
return this.orgsMap.delete(parseInt(id)); return this.orgsMap.delete(parseInt(id));
} }
// Group management // Group management methods have been removed
async getGroup(id: string): Promise<Group | undefined> {
return this.groupsMap.get(parseInt(id));
}
async getGroups(): Promise<Group[]> {
return Array.from(this.groupsMap.values());
}
async getGroupMembers(groupId: string): Promise<GroupMember[]> {
return Array.from(this.groupMembersMap.values())
.filter(member => member.groupId === groupId);
}
async createGroup(group: InsertGroup): Promise<Group> {
const numId = this.groupIdCounter++;
const createdAt = new Date();
const newGroup: Group = {
id: numId.toString(),
name: group.name,
description: group.description || null,
isActive: group.isActive ?? true,
createdBy: group.createdBy,
parentGroupId: group.parentGroupId || null,
createdAt
};
this.groupsMap.set(numId, newGroup);
return newGroup;
}
async updateGroup(id: string, groupData: Partial<InsertGroup>): Promise<Group | undefined> {
const numId = parseInt(id);
const group = await this.getGroup(id);
if (!group) return undefined;
const updatedGroup = { ...group, ...groupData };
this.groupsMap.set(numId, updatedGroup);
return updatedGroup;
}
async deleteGroup(id: string): Promise<boolean> {
return this.groupsMap.delete(parseInt(id));
}
async addGroupMember(member: InsertGroupMember): Promise<GroupMember> {
const numId = this.groupMemberIdCounter++;
const addedAt = new Date();
const newMember: GroupMember = {
id: numId.toString(),
groupId: member.groupId,
memberId: member.memberId,
memberType: member.memberType,
addedBy: member.addedBy,
addedAt
};
this.groupMembersMap.set(numId, newMember);
return newMember;
}
async removeGroupMember(id: string): Promise<boolean> {
return this.groupMembersMap.delete(parseInt(id));
}
// Domains // Domains
async getDomain(id: string): Promise<Domain | undefined> { async getDomain(id: string): Promise<Domain | undefined> {