Ignore:
Timestamp:
12/23/25 04:22:06 (7 months ago)
Author:
Tome <gjorgievtome@…>
Branches:
main
Children:
6196d60
Parents:
226fbbb
Message:

Update and add

File:
1 edited

Legend:

Unmodified
Added
Removed

  • database/drizzle/queries/components.ts

    r226fbbb rea09e98  
    11import type { Database } from "../db";
    2 import {buildsTable, componentsTable } from "../schema";
     2import {
     3    buildsTable, cablesTable, caseMoboFormFactorsTable, casePsFormFactorsTable, caseStorageFormFactorsTable,
     4    componentsTable, coolerCPUSocketsTable, coolersTable,
     5    CPUTable,
     6    GPUTable, memoryCardsTable,
     7    memoryTable, motherboardsTable,
     8    networkAdaptersTable,
     9    networkCardsTable, opticalDrivesTable, pcCasesTable, powerSupplyTable, soundCardsTable, storageTable
     10} from "../schema";
    311import {and, desc, eq, ilike} from "drizzle-orm";
    412
    … …  
    4250
    4351export async function getComponentDetails(db: Database, componentId: number) {
    44     const [componentDetails] = await db
     52    const [component] = await db
    4553        .select()
    4654        .from(componentsTable)
    … …  
    5058        .limit(1);
    5159
    52     return componentDetails ?? null;
     60    if(!component) return null;
     61
     62    if (!component) return null;
     63
     64    let details: any = {};
     65
     66    switch (component.type) {
     67        case 'cpu':
     68            [details] = await db.select().from(CPUTable).where(eq(CPUTable.componentId, componentId));
     69            break;
     70        case 'gpu':
     71            [details] = await db.select().from(GPUTable).where(eq(GPUTable.componentId, componentId));
     72            break;
     73        case 'memory':
     74            [details] = await db.select().from(memoryTable).where(eq(memoryTable.componentId, componentId));
     75            break;
     76        case 'power_supply':
     77            [details] = await db.select().from(powerSupplyTable).where(eq(powerSupplyTable.componentId, componentId));
     78            break;
     79        case 'case':
     80            [details] = await db.select().from(pcCasesTable).where(eq(pcCasesTable.componentId, componentId));
     81            if (details) {
     82                details.storageFormFactors = await db.select().from(caseStorageFormFactorsTable).where(eq(caseStorageFormFactorsTable.caseId, componentId));
     83                details.psFormFactors = await db.select().from(casePsFormFactorsTable).where(eq(casePsFormFactorsTable.caseId, componentId));
     84                details.moboFormFactors = await db.select().from(caseMoboFormFactorsTable).where(eq(caseMoboFormFactorsTable.caseId, componentId));
     85            }
     86            break;
     87        case 'cooler':
     88            [details] = await db.select().from(coolersTable).where(eq(coolersTable.componentId, componentId));
     89            if (details) {
     90                details.cpuSockets = await db.select().from(coolerCPUSocketsTable).where(eq(coolerCPUSocketsTable.coolerId, componentId));
     91            }
     92            break;
     93        case 'motherboard':
     94            [details] = await db.select().from(motherboardsTable).where(eq(motherboardsTable.componentId, componentId));
     95            break;
     96        case 'storage':
     97            [details] = await db.select().from(storageTable).where(eq(storageTable.componentId, componentId));
     98            break;
     99        case 'memory_card':
     100            [details] = await db.select().from(memoryCardsTable).where(eq(memoryCardsTable.componentId, componentId));
     101            break;
     102        case 'optical_drive':
     103            [details] = await db.select().from(opticalDrivesTable).where(eq(opticalDrivesTable.componentId, componentId));
     104            break;
     105        case 'sound_card':
     106            [details] = await db.select().from(soundCardsTable).where(eq(soundCardsTable.componentId, componentId));
     107            break;
     108        case 'cables':
     109            [details] = await db.select().from(cablesTable).where(eq(cablesTable.componentId, componentId));
     110            break;
     111        case 'network_adapter':
     112            [details] = await db.select().from(networkAdaptersTable).where(eq(networkAdaptersTable.componentId, componentId));
     113            break;
     114        case 'network_card':
     115            [details] = await db.select().from(networkCardsTable).where(eq(networkCardsTable.componentId, componentId));
     116            break;
     117    }
     118
     119    return {
     120        ...component,
     121        details: details || null
     122    };
    53123}
     124
     125export async function addNewComponent(db: Database, name: string, brand: string, price: number, imgUrl: string, type: string, specificData: any) {
     126    return db.transaction(async (tx) => {
     127        const [newComponent] = await tx
     128            .insert(componentsTable)
     129            .values({
     130                name: name,
     131                brand: brand,
     132                price: price.toFixed(2),
     133                imgUrl: imgUrl,
     134                type: type
     135            })
     136            .returning({
     137                id: componentsTable.id
     138            });
     139
     140        const componentId = newComponent.id;
     141
     142        switch (type) {
     143            case 'cpu':
     144                await tx.insert(CPUTable).values({
     145                    componentId,
     146                    socket: specificData.socket,
     147                    cores: specificData.cores,
     148                    threads: specificData.threads,
     149                    baseClock: specificData.baseClock,
     150                    boostClock: specificData.boostClock,
     151                    tdp: specificData.tdp,
     152                });
     153                break;
     154
     155            case 'gpu':
     156                await tx.insert(GPUTable).values({
     157                    componentId,
     158                    vram: specificData.vram,
     159                    tdp: specificData.tdp,
     160                    baseClock: specificData.baseClock,
     161                    boostClock: specificData.boostClock,
     162                    chipset: specificData.chipset,
     163                    length: specificData.length,
     164                });
     165                break;
     166
     167            case 'memory':
     168                await tx.insert(memoryTable).values({
     169                    componentId,
     170                    type: specificData.type,
     171                    speed: specificData.speed,
     172                    capacity: specificData.capacity,
     173                    modules: specificData.modules,
     174                });
     175                break;
     176
     177            case 'power_supply':
     178                await tx.insert(powerSupplyTable).values({
     179                    componentId,
     180                    type: specificData.type,
     181                    wattage: specificData.wattage,
     182                    formFactor: specificData.formFactor,
     183                });
     184                break;
     185
     186            case 'case':
     187                await tx.insert(pcCasesTable).values({
     188                    componentId,
     189                    coolerMaxHeight: specificData.coolerMaxHeight,
     190                    gpuMaxLength: specificData.gpuMaxLength,
     191                });
     192
     193                if (specificData.storageFormFactors) {
     194                    await tx.insert(caseStorageFormFactorsTable).values(
     195                        specificData.storageFormFactors.map((sf: any) => ({
     196                            caseId: componentId,
     197                            formFactor: sf.formFactor,
     198                            numSlots: sf.numSlots,
     199                        }))
     200                    );
     201                }
     202
     203                if (specificData.psFormFactors) {
     204                    await tx.insert(casePsFormFactorsTable).values(
     205                        specificData.psFormFactors.map((pf: any) => ({
     206                            caseId: componentId,
     207                            formFactor: pf.formFactor,
     208                        }))
     209                    );
     210                }
     211
     212                if (specificData.moboFormFactors) {
     213                    await tx.insert(caseMoboFormFactorsTable).values(
     214                        specificData.moboFormFactors.map((mf: any) => ({
     215                            caseId: componentId,
     216                            formFactor: mf.formFactor,
     217                        }))
     218                    );
     219                }
     220                break;
     221
     222            case 'cooler':
     223                await tx.insert(coolersTable).values({
     224                    componentId,
     225                    type: specificData.type,
     226                    height: specificData.height,
     227                    maxTdpSupported: specificData.maxTdpSupported,
     228                });
     229
     230                if (specificData.cpuSockets) {
     231                    await tx.insert(coolerCPUSocketsTable).values(
     232                        specificData.cpuSockets.map((socket: string) => ({
     233                            coolerId: componentId,
     234                            socket: socket,
     235                        }))
     236                    );
     237                }
     238                break;
     239
     240            case 'motherboard':
     241                await tx.insert(motherboardsTable).values({
     242                    componentId,
     243                    socket: specificData.socket,
     244                    chipset: specificData.chipset,
     245                    formFactor: specificData.formFactor,
     246                    ramType: specificData.ramType,
     247                    numRamSlots: specificData.numRamSlots,
     248                    maxRamCapacity: specificData.maxRamCapacity,
     249                });
     250                break;
     251
     252            case 'storage':
     253                await tx.insert(storageTable).values({
     254                    componentId,
     255                    type: specificData.type,
     256                    capacity: specificData.capacity,
     257                    formFactor: specificData.formFactor,
     258                });
     259                break;
     260
     261            case 'memory_card':
     262                await tx.insert(memoryCardsTable).values({
     263                    componentId,
     264                    numSlots: specificData.numSlots,
     265                    interface: specificData.interface,
     266                });
     267                break;
     268
     269            case 'optical_drive':
     270                await tx.insert(opticalDrivesTable).values({
     271                    componentId,
     272                    formFactor: specificData.formFactor,
     273                    type: specificData.type,
     274                    interface: specificData.interface,
     275                    writeSpeed: specificData.writeSpeed,
     276                    readSpeed: specificData.readSpeed,
     277                });
     278                break;
     279
     280            case 'sound_card':
     281                await tx.insert(soundCardsTable).values({
     282                    componentId,
     283                    sampleRate: specificData.sampleRate,
     284                    bitDepth: specificData.bitDepth,
     285                    chipset: specificData.chipset,
     286                    interface: specificData.interface,
     287                    channel: specificData.channel,
     288                });
     289                break;
     290
     291            case 'cables':
     292                await tx.insert(cablesTable).values({
     293                    componentId,
     294                    lengthCm: specificData.lengthCm,
     295                    type: specificData.type,
     296                });
     297                break;
     298
     299            case 'network_adapter':
     300                await tx.insert(networkAdaptersTable).values({
     301                    componentId,
     302                    wifiVersion: specificData.wifiVersion,
     303                    interface: specificData.interface,
     304                    numAntennas: specificData.numAntennas,
     305                });
     306                break;
     307
     308            case 'network_card':
     309                await tx.insert(networkCardsTable).values({
     310                    componentId,
     311                    numPorts: specificData.numPorts,
     312                    speed: specificData.speed,
     313                    interface: specificData.interface,
     314                });
     315                break;
     316
     317            default:
     318                return null;
     319        }
     320
     321        return componentId;
     322    });
     323}
Note: See TracChangeset for help on using the changeset viewer.