feat: added controller. modules and services for each model in database

monorepo/apps/backend/src/app/app.module.ts

@@ -3,9 +3,27 @@ import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { DatabaseModule } from './database/database.module';
+import { RestauracjaModule } from './restauracja/restauracja.module';
+import { RecenzjaModule } from './recenzja/recenzja.module';
+import { UzytkownikModule } from './uzytkownik/uzytkownik.module';
+import { HistoriaZamowienModule } from './historia-zamowien/historia-zamowien.module';
+import { DanieModule } from './danie/danie.module';
+import { ZamowioneDanieModule } from './zamowione-danie/zamowione-danie.module';
+import { ZamowienieModule } from './zamowienie/zamowienie.module';
+import { ZnizkaModule } from './znizka/znizka.module';
 
 @Module({
-  imports: [DatabaseModule],
+  imports: [
+    DatabaseModule,
+    RestauracjaModule,
+    RecenzjaModule,
+    UzytkownikModule,
+    HistoriaZamowienModule,
+    DanieModule,
+    ZamowioneDanieModule,
+    ZamowienieModule,
+    ZnizkaModule,
+  ],
   controllers: [AppController],
   providers: [AppService],
 })

monorepo/apps/backend/src/app/danie/danie.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DanieController } from './danie.controller';
+
+describe('DanieController', () => {
+  let controller: DanieController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [DanieController],
+    }).compile();
+
+    controller = module.get<DanieController>(DanieController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/danie/danie.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('danie')
+export class DanieController {}

monorepo/apps/backend/src/app/danie/danie.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { DanieService } from './danie.service';
+import { DanieController } from './danie.controller';
+
+@Module({
+  providers: [DanieService],
+  controllers: [DanieController],
+})
+export class DanieModule {}

monorepo/apps/backend/src/app/danie/danie.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DanieService } from './danie.service';
+
+describe('DanieService', () => {
+  let service: DanieService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [DanieService],
+    }).compile();
+
+    service = module.get<DanieService>(DanieService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/danie/danie.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class DanieService {}

monorepo/apps/backend/src/app/database/database.module.ts

@@ -5,5 +5,6 @@ import { DatabaseService } from './database.service';
 @Module({
   controllers: [DatabaseController],
   providers: [DatabaseService],
+  exports: [DatabaseService]
 })
 export class DatabaseModule {}

monorepo/apps/backend/src/app/database/database.service.ts

@@ -1,4 +1,13 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
 
 @Injectable()
-export class DatabaseService {}
+export class DatabaseService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+    async onModuleInit() {
+      await this.$connect();
+    }
+  
+    async onModuleDestroy() {
+      await this.$disconnect();
+    }
+  }

monorepo/apps/backend/src/app/historia-zamowien/historia-zamowien.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HistoriaZamowienController } from './historia-zamowien.controller';
+
+describe('HistoriaZamowienController', () => {
+  let controller: HistoriaZamowienController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [HistoriaZamowienController],
+    }).compile();
+
+    controller = module.get<HistoriaZamowienController>(
+      HistoriaZamowienController
+    );
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/historia-zamowien/historia-zamowien.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('historia-zamowien')
+export class HistoriaZamowienController {}

monorepo/apps/backend/src/app/historia-zamowien/historia-zamowien.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { HistoriaZamowienService } from './historia-zamowien.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { HistoriaZamowienController } from './historia-zamowien.controller';
+
+@Module({
+  providers: [HistoriaZamowienService, DatabaseService],
+  controllers: [HistoriaZamowienController],
+})
+export class HistoriaZamowienModule {}

monorepo/apps/backend/src/app/historia-zamowien/historia-zamowien.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HistoriaZamowienService } from './historia-zamowien.service';
+
+describe('HistoriaZamowienService', () => {
+  let service: HistoriaZamowienService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [HistoriaZamowienService],
+    }).compile();
+
+    service = module.get<HistoriaZamowienService>(HistoriaZamowienService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/historia-zamowien/historia-zamowien.service.ts

@@ -0,0 +1,29 @@
+// src/historia-zamowien/historia-zamowien.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Historia_zamowien } from '@prisma/client';
+
+@Injectable()
+export class HistoriaZamowienService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Historia_zamowien[]> {
+    return this.prisma.historia_zamowien.findMany();
+  }
+
+  async findOne(id: number): Promise<Historia_zamowien | null> {
+    return this.prisma.historia_zamowien.findUnique({ where: { id } });
+  }
+
+  async create(data: { data_zamowienia: Date }): Promise<Historia_zamowien> {
+    return this.prisma.historia_zamowien.create({ data });
+  }
+
+  async update(id: number, data: Partial<Historia_zamowien>): Promise<Historia_zamowien> {
+    return this.prisma.historia_zamowien.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Historia_zamowien> {
+    return this.prisma.historia_zamowien.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/recenzja/recenzja.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RecenzjaController } from './recenzja.controller';
+
+describe('RecenzjaController', () => {
+  let controller: RecenzjaController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [RecenzjaController],
+    }).compile();
+
+    controller = module.get<RecenzjaController>(RecenzjaController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/recenzja/recenzja.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('recenzja')
+export class RecenzjaController {}

monorepo/apps/backend/src/app/recenzja/recenzja.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { RecenzjaService } from './recenzja.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { RecenzjaController } from './recenzja.controller';
+
+@Module({
+  providers: [RecenzjaService, DatabaseService],
+  exports: [RecenzjaService],
+  controllers: [RecenzjaController],
+})
+export class RecenzjaModule {}

monorepo/apps/backend/src/app/recenzja/recenzja.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RecenzjaService } from './recenzja.service';
+
+describe('RecenzjaService', () => {
+  let service: RecenzjaService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [RecenzjaService],
+    }).compile();
+
+    service = module.get<RecenzjaService>(RecenzjaService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/recenzja/recenzja.service.ts

@@ -0,0 +1,29 @@
+// src/recenzja/recenzja.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Recenzja } from '@prisma/client';
+
+@Injectable()
+export class RecenzjaService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Recenzja[]> {
+    return this.prisma.recenzja.findMany();
+  }
+
+  async findOne(id: number): Promise<Recenzja | null> {
+    return this.prisma.recenzja.findUnique({ where: { id } });
+  }
+
+  async create(data: { tekst: string; wartosc: number; restauracjaId: number; uzytkownikId: number }): Promise<Recenzja> {
+    return this.prisma.recenzja.create({ data });
+  }
+
+  async update(id: number, data: Partial<Recenzja>): Promise<Recenzja> {
+    return this.prisma.recenzja.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Recenzja> {
+    return this.prisma.recenzja.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/restauracja/restauracja.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RestauracjaController } from './restauracja.controller';
+
+describe('RestauracjaController', () => {
+  let controller: RestauracjaController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [RestauracjaController],
+    }).compile();
+
+    controller = module.get<RestauracjaController>(RestauracjaController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/restauracja/restauracja.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('restauracja')
+export class RestauracjaController {}

monorepo/apps/backend/src/app/restauracja/restauracja.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { RestauracjaService } from './restauracja.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { RestauracjaController } from './restauracja.controller';
+
+@Module({
+  providers: [RestauracjaService, DatabaseService],
+  imports: [DatabaseModule],
+  controllers: [RestauracjaController],
+})
+export class RestauracjaModule {}

monorepo/apps/backend/src/app/restauracja/restauracja.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RestauracjaService } from './restauracja.service';
+
+describe('RestauracjaService', () => {
+  let service: RestauracjaService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [RestauracjaService],
+    }).compile();
+
+    service = module.get<RestauracjaService>(RestauracjaService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/restauracja/restauracja.service.ts

@@ -0,0 +1,29 @@
+// src/restauracja/restauracja.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Restauracja } from '@prisma/client';
+
+@Injectable()
+export class RestauracjaService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Restauracja[]> {
+    return this.prisma.restauracja.findMany();
+  }
+
+  async findOne(id: number): Promise<Restauracja | null> {
+    return this.prisma.restauracja.findUnique({ where: { id } });
+  }
+
+  async create(data: { adres: string }): Promise<Restauracja> {
+    return this.prisma.restauracja.create({ data });
+  }
+
+  async update(id: number, data: Partial<Restauracja>): Promise<Restauracja> {
+    return this.prisma.restauracja.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Restauracja> {
+    return this.prisma.restauracja.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/uzytkownik/uzytkownik.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UzytkownikController } from './uzytkownik.controller';
+
+describe('UzytkownikController', () => {
+  let controller: UzytkownikController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [UzytkownikController],
+    }).compile();
+
+    controller = module.get<UzytkownikController>(UzytkownikController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/uzytkownik/uzytkownik.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('uzytkownik')
+export class UzytkownikController {}

monorepo/apps/backend/src/app/uzytkownik/uzytkownik.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { UzytkownikService } from './uzytkownik.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { UzytkownikController } from './uzytkownik.controller';
+
+@Module({
+  providers: [UzytkownikService, DatabaseService],
+  controllers: [UzytkownikController],
+})
+export class UzytkownikModule {}

monorepo/apps/backend/src/app/uzytkownik/uzytkownik.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UzytkownikService } from './uzytkownik.service';
+
+describe('UzytkownikService', () => {
+  let service: UzytkownikService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [UzytkownikService],
+    }).compile();
+
+    service = module.get<UzytkownikService>(UzytkownikService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/uzytkownik/uzytkownik.service.ts

@@ -0,0 +1,29 @@
+// src/uzytkownik/uzytkownik.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Uzytkownik } from '@prisma/client';
+
+@Injectable()
+export class UzytkownikService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Uzytkownik[]> {
+    return this.prisma.uzytkownik.findMany();
+  }
+
+  async findOne(id: number): Promise<Uzytkownik | null> {
+    return this.prisma.uzytkownik.findUnique({ where: { id } });
+  }
+
+  async create(data: { imie: string; nazwisko: string; adres: string; Historia_zamowienId: number }): Promise<Uzytkownik> {
+    return this.prisma.uzytkownik.create({ data });
+  }
+
+  async update(id: number, data: Partial<Uzytkownik>): Promise<Uzytkownik> {
+    return this.prisma.uzytkownik.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Uzytkownik> {
+    return this.prisma.uzytkownik.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/zamowienie/zamowienie.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZamowienieController } from './zamowienie.controller';
+
+describe('ZamowienieController', () => {
+  let controller: ZamowienieController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ZamowienieController],
+    }).compile();
+
+    controller = module.get<ZamowienieController>(ZamowienieController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/zamowienie/zamowienie.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('zamowienie')
+export class ZamowienieController {}

monorepo/apps/backend/src/app/zamowienie/zamowienie.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ZamowienieService } from './zamowienie.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { ZamowienieController } from './zamowienie.controller';
+
+@Module({
+  providers: [ZamowienieService, DatabaseService],
+  controllers: [ZamowienieController],
+})
+export class ZamowienieModule {}

monorepo/apps/backend/src/app/zamowienie/zamowienie.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZamowienieService } from './zamowienie.service';
+
+describe('ZamowienieService', () => {
+  let service: ZamowienieService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ZamowienieService],
+    }).compile();
+
+    service = module.get<ZamowienieService>(ZamowienieService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/zamowienie/zamowienie.service.ts

@@ -0,0 +1,29 @@
+// src/zamowienie/zamowienie.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Zamowienie } from '@prisma/client';
+
+@Injectable()
+export class ZamowienieService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Zamowienie[]> {
+    return this.prisma.zamowienie.findMany();
+  }
+
+  async findOne(id: number): Promise<Zamowienie | null> {
+    return this.prisma.zamowienie.findUnique({ where: { id } });
+  }
+
+  async create(data: { status: string }): Promise<Zamowienie> {
+    return this.prisma.zamowienie.create({ data });
+  }
+
+  async update(id: number, data: Partial<Zamowienie>): Promise<Zamowienie> {
+    return this.prisma.zamowienie.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Zamowienie> {
+    return this.prisma.zamowienie.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/zamowione-danie/zamowione-danie.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZamowioneDanieController } from './zamowione-danie.controller';
+
+describe('ZamowioneDanieController', () => {
+  let controller: ZamowioneDanieController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ZamowioneDanieController],
+    }).compile();
+
+    controller = module.get<ZamowioneDanieController>(ZamowioneDanieController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/zamowione-danie/zamowione-danie.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('zamowione-danie')
+export class ZamowioneDanieController {}

monorepo/apps/backend/src/app/zamowione-danie/zamowione-danie.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ZamowioneDanieService } from './zamowione-danie.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { ZamowioneDanieController } from './zamowione-danie.controller';
+
+@Module({
+  providers: [ZamowioneDanieService, DatabaseService],
+  controllers: [ZamowioneDanieController],
+})
+export class ZamowioneDanieModule {}

monorepo/apps/backend/src/app/zamowione-danie/zamowione-danie.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZamowioneDanieService } from './zamowione-danie.service';
+
+describe('ZamowioneDanieService', () => {
+  let service: ZamowioneDanieService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ZamowioneDanieService],
+    }).compile();
+
+    service = module.get<ZamowioneDanieService>(ZamowioneDanieService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/zamowione-danie/zamowione-danie.service.ts

@@ -0,0 +1,29 @@
+// src/zamowione-danie/zamowione-danie.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Zamowione_danie } from '@prisma/client';
+
+@Injectable()
+export class ZamowioneDanieService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Zamowione_danie[]> {
+    return this.prisma.zamowione_danie.findMany();
+  }
+
+  async findOne(id: number): Promise<Zamowione_danie | null> {
+    return this.prisma.zamowione_danie.findUnique({ where: { id } });
+  }
+
+  async create(data: { zamowienieId: number }): Promise<Zamowione_danie> {
+    return this.prisma.zamowione_danie.create({ data });
+  }
+
+  async update(id: number, data: Partial<Zamowione_danie>): Promise<Zamowione_danie> {
+    return this.prisma.zamowione_danie.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Zamowione_danie> {
+    return this.prisma.zamowione_danie.delete({ where: { id } });
+  }
+}

monorepo/apps/backend/src/app/znizka/znizka.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZnizkaController } from './znizka.controller';
+
+describe('ZnizkaController', () => {
+  let controller: ZnizkaController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ZnizkaController],
+    }).compile();
+
+    controller = module.get<ZnizkaController>(ZnizkaController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/znizka/znizka.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('znizka')
+export class ZnizkaController {}

monorepo/apps/backend/src/app/znizka/znizka.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ZnizkaService } from './znizka.service';
+import { DatabaseModule } from '../database/database.module';
+import { DatabaseService } from '../database/database.service';
+import { ZnizkaController } from './znizka.controller';
+
+@Module({
+  providers: [ZnizkaService, DatabaseService],
+  controllers: [ZnizkaController],
+})
+export class ZnizkaModule {}

monorepo/apps/backend/src/app/znizka/znizka.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ZnizkaService } from './znizka.service';
+
+describe('ZnizkaService', () => {
+  let service: ZnizkaService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ZnizkaService],
+    }).compile();
+
+    service = module.get<ZnizkaService>(ZnizkaService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

monorepo/apps/backend/src/app/znizka/znizka.service.ts

@@ -0,0 +1,29 @@
+// src/znizka/znizka.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import { Znizka } from '@prisma/client';
+
+@Injectable()
+export class ZnizkaService {
+  constructor(private prisma: DatabaseService) {}
+
+  async findAll(): Promise<Znizka[]> {
+    return this.prisma.znizka.findMany();
+  }
+
+  async findOne(id: number): Promise<Znizka | null> {
+    return this.prisma.znizka.findUnique({ where: { id } });
+  }
+
+  async create(data: { kod: string; wartosc: number; czy_dostepna: boolean; restauracjaId: number }): Promise<Znizka> {
+    return this.prisma.znizka.create({ data });
+  }
+
+  async update(id: number, data: Partial<Znizka>): Promise<Znizka> {
+    return this.prisma.znizka.update({ where: { id }, data });
+  }
+
+  async delete(id: number): Promise<Znizka> {
+    return this.prisma.znizka.delete({ where: { id } });
+  }
+}

monorepo/generate.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Define the project name
+PROJECT_NAME="backend"
+
+# Function to generate a module and a service
+generate_module_and_service() {
+  MODULE_NAME=$1
+
+  echo "Generating module and service for ${MODULE_NAME}..."
+
+  # Generate module in the specific directory
+  # nx g @nrwl/nest:module ${MODULE_NAME} --directory=apps/${PROJECT_NAME}/src/app/${MODULE_NAME}
+
+  # Generate service in the specific directory
+  # nx g @nrwl/nest:service ${MODULE_NAME} --directory=apps/${PROJECT_NAME}/src/app/${MODULE_NAME}
+
+  nx g @nrwl/nest:controller ${MODULE_NAME} --directory=apps/${PROJECT_NAME}/src/app/${MODULE_NAME}
+}
+
+# List of all models for which we need to generate modules and services
+MODELS=("restauracja" "recenzja" "uzytkownik" "historia-zamowien" "danie" "zamowione-danie" "zamowienie" "znizka")
+
+# Loop through the models and generate modules and services
+for MODEL in "${MODELS[@]}"; do
+  generate_module_and_service ${MODEL}
+done
+
+echo "All modules and services have been generated successfully."