@hed-hog/core 0.0.297 → 0.0.299

package/src/file/file.controller.ts

@@ -2,19 +2,19 @@ import { Public, Role } from '@hed-hog/api';
 import { getLocaleText, Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
-  Body,
-  Controller,
-  Delete,
-  forwardRef,
-  Get,
-  Inject,
-  Param,
-  ParseIntPipe,
-  Post,
-  Put,
-  Res,
-  UploadedFile,
-  UseInterceptors,
+    Body,
+    Controller,
+    Delete,
+    forwardRef,
+    Get,
+    Inject,
+    Param,
+    ParseIntPipe,
+    Post,
+    Put,
+    Res,
+    UploadedFile,
+    UseInterceptors,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { Response } from 'express';
@@ -127,6 +127,30 @@ export class FileController {
 
     try {
 
+      const numericId = Number(token);
+      const isNumericId = Number.isInteger(numericId) && String(numericId) === token;
+
+      if (isNumericId && numericId > 0) {
+        const { stream, filename, mimetype, size } =
+          await this.fileService.openById(locale, numericId);
+
+        const encodedFilename = encodeURIComponent(filename);
+
+        res.set({
+          'Content-Type': mimetype || 'application/octet-stream',
+          'Content-Disposition':
+            `inline; filename="${filename}"; ` +
+            `filename*=UTF-8''${encodedFilename}`,
+        });
+
+        if (typeof size === 'number') {
+          res.set('Content-Length', `${size}`);
+        }
+
+        stream.pipe(res);
+        return;
+      }
+
       const { stream, filename, mimetype, size } =
         await this.fileService.download(locale, token);
 

package/src/file/file.service.ts

@@ -258,11 +258,26 @@ export class FileService implements OnModuleInit {
 
     const provider = await this.getProvider();
 
-    const buffer = Buffer.from(
-      await provider.buffer(
-        storage === EnumProvider.LOCAL ? file.path : (new URL(file.path)).pathname
-      )
-    );
+    const providerPath =
+      storage === EnumProvider.LOCAL ? file.path : new URL(file.path).pathname;
+
+    let providerBuffer: Buffer;
+    try {
+      providerBuffer = await provider.buffer(providerPath);
+    } catch (error: any) {
+      const missingInStorage =
+        error?.name === 'NoSuchKey' ||
+        error?.Code === 'NoSuchKey' ||
+        error?.$metadata?.httpStatusCode === 404;
+
+      if (missingInStorage) {
+        throw new NotFoundException(`File not found in storage: ${fileId}`);
+      }
+
+      throw error;
+    }
+
+    const buffer = Buffer.from(providerBuffer);
 
     return {
       file,
@@ -453,6 +468,33 @@ export class FileService implements OnModuleInit {
     }
   }
 
+  async openById(locale: string, fileId: number) {
+    const file = await this.prismaService.file.findFirst({
+      where: { id: fileId },
+      include: {
+        file_mimetype: true,
+      },
+    });
+
+    if (!file) {
+      throw new NotFoundException(
+        getLocaleText('file.download.not_found', locale, `Not found: ${fileId}`),
+      );
+    }
+
+    const provider = await this.getProvider();
+    const metadata = await provider.metaData(file.path);
+    const stream = await provider.readStream(file.path);
+    const size = this.getFileSizeFromMetadata(metadata);
+
+    return {
+      stream,
+      filename: file?.filename || 'download',
+      mimetype: file?.file_mimetype?.name || 'application/octet-stream',
+      size,
+    };
+  }
+
   async tempURL(filepath: string, expires = 3600) {
     return (await this.getProvider()).tempURL(filepath, expires);
   }

package/src/file/provider/s3.provider.ts

@@ -21,15 +21,33 @@ export class S3Provider extends AbstractProvider {
     this.initValidation();
   }
 
+  private resolveS3Key(filepath: string): string {
+    if (!filepath) {
+      throw new Error('Invalid filepath for S3');
+    }
+
+    try {
+      const url = new URL(filepath);
+      const keyFromUrl = url.pathname.split('/').filter(Boolean).join('/');
+      if (!keyFromUrl) {
+        throw new Error(`Invalid filepath "${filepath}" for S3`);
+      }
+      return keyFromUrl;
+    } catch {
+      const keyFromPath = filepath.split('/').filter(Boolean).join('/');
+      if (!keyFromPath) {
+        throw new Error(`Invalid filepath "${filepath}" for S3`);
+      }
+      return keyFromPath;
+    }
+  }
+
   async buffer(filepath: string): Promise<Buffer> {
     const s3 = await this.getClient();
-    const url = new URL(filepath);
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
+    const key = this.resolveS3Key(filepath);
     const command = new GetObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: url.pathname.split('/').slice(1).join('/'),
+      Key: key,
     });
     const result = await s3.send(command);
     // @ts-ignore
@@ -123,37 +141,38 @@ export class S3Provider extends AbstractProvider {
     fileContent: string,
   ): Promise<any> {
     const s3 = await this.getClient();
+    const storedFilename = this.getFilename(filename);
+    const key = [destination, storedFilename].join('/');
     const command = new PutObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: [destination, this.getFilename(filename)].join('/'),
+      Key: key,
       Body: fileContent,
     });
     await s3.send(command);
     // S3 v3 não retorna Location diretamente, construa a URL:
-    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${destination}/${this.getFilename(filename)}`;
+    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
   }
 
   async upload(destination: string, file: MulterFile): Promise<any> {
     const s3 = await this.getClient();
+    const storedFilename = this.getFilename(file.originalname);
+    const key = [destination, storedFilename].join('/');
     const command = new PutObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: [destination, this.getFilename(file.originalname)].join('/'),
+      Key: key,
       Body: file.buffer,
     });
     await s3.send(command);
-    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${destination}/${this.getFilename(file.originalname)}`;
+    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
   }
 
   async delete(filepath: string): Promise<any> {
     const s3 = await this.getClient();
-    const url = new URL(filepath);
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
+    const key = this.resolveS3Key(filepath);
     await s3.send(
       new DeleteObjectCommand({
         Bucket: this.setting['storage-s3-bucket'],
-        Key: url.pathname.split('/').slice(1).join('/'),
+        Key: key,
       }),
     );
     return true;
@@ -161,13 +180,10 @@ export class S3Provider extends AbstractProvider {
 
   async readStream(filepath: string): Promise<Readable> {
     const s3 = await this.getClient();
-    const url = new URL(filepath);
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
+    const key = this.resolveS3Key(filepath);
     const command = new GetObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: url.pathname.split('/').slice(1).join('/'),
+      Key: key,
     });
     const result = await s3.send(command);
     // @ts-ignore
@@ -176,13 +192,10 @@ export class S3Provider extends AbstractProvider {
 
   async metaData(filepath: string): Promise<any> {
     const s3 = await this.getClient();
-    const url = new URL(filepath);
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
+    const key = this.resolveS3Key(filepath);
     const command = new HeadObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: url.pathname.split('/').slice(1).join('/'),
+      Key: key,
     });
     const result = await s3.send(command);
     return result; // returns metadata
@@ -190,13 +203,10 @@ export class S3Provider extends AbstractProvider {
 
   async tempURL(filepath: string, expires = 3600): Promise<string> {
     const s3Client = await this.getS3Client();
-    const url = new URL(filepath);
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
+    const key = this.resolveS3Key(filepath);
     const command = new GetObjectCommand({
       Bucket: this.setting['storage-s3-bucket'],
-      Key: url.pathname.split('/').slice(1).join('/'),
+      Key: key,
     });
     // Use S3Client instance for getSignedUrl
     return await getSignedUrl(s3Client as any, command, { expiresIn: expires });

package/src/oauth/oauth.service.ts

@@ -1,11 +1,11 @@
 import { PrismaService, user_account_provider_52222e2ecb_enum } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    ConflictException,
-    Inject,
-    Injectable,
-    NotFoundException,
-    forwardRef
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef
 } from '@nestjs/common';
 import { AuthService } from '../auth/auth.service';
 import { FileService } from '../file/file.service';
@@ -13,6 +13,7 @@ import { MailService } from '../mail/mail.service';
 import { SecurityService } from '../security/security.service';
 import { SettingService } from '../setting/setting.service';
 import { TokenService } from '../token/token.service';
+import { USER_AVATAR_UPLOAD_DESTINATION } from '../user/constants/user.constants';
 import { UserService } from '../user/user.service';
 import { OAuthProvider } from './interfaces/OAuthProvider';
 import { FacebookProvider } from './providers/facebook.provider';
@@ -385,7 +386,7 @@ export class OAuthService {
       size: buffer.length,
     } as any;
 
-    const savedFile = await this.file.upload('profile-pictures', file);
+    const savedFile = await this.file.upload(USER_AVATAR_UPLOAD_DESTINATION, file);
     return savedFile.id;
   }
 }

package/src/user/constants/user.constants.ts

@@ -1 +1,2 @@
 export const SALT_ROUNDS = 10;
+export const USER_AVATAR_UPLOAD_DESTINATION = 'profile-pictures';

package/src/user/user.service.ts

@@ -12,6 +12,7 @@ import { ChallengeService } from '../challenge/challenge.service';
 import { DeleteDTO } from '../dto/delete.dto';
 import { FileService } from '../file/file.service';
 import { SecurityService } from '../security/security.service';
+import { USER_AVATAR_UPLOAD_DESTINATION } from './constants/user.constants';
 import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
 import { ResetPasswordDTO } from './dto/reset-password.dto';
 import { UpdateDTO } from './dto/update.dto';
@@ -272,7 +273,7 @@ export class UserService {
   async changeAvatar(locale: string, userId: number, avatar: MulterFile) {
     const user = await this.validateUserExists(locale, userId);
 
-    const newFile = await this.file.upload('user/avatar', avatar);
+    const newFile = await this.file.upload(USER_AVATAR_UPLOAD_DESTINATION, avatar);
 
     await this.deleteOldAvatar(locale, user.photo_id);
 

package/hedhog/frontend/app/dashboard/components/widgets/locale-config.tsx.ejs

@@ -1,309 +0,0 @@
-'use client';
-
-import { Badge } from '@/components/ui/badge';
-import { Button } from '@/components/ui/button';
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from '@/components/ui/card';
-import { Checkbox } from '@/components/ui/checkbox';
-import { Label } from '@/components/ui/label';
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select';
-import { Switch } from '@/components/ui/switch';
-import { Calendar, CheckCircle2, Clock, Globe, Type } from 'lucide-react';
-import { useState } from 'react';
-
-interface Language {
-  code: string;
-  label: string;
-  flag: string;
-  enabled: boolean;
-}
-
-const availableLanguages: Language[] = [
-  { code: 'pt-BR', label: 'Portugues (Brasil)', flag: '🇧🇷', enabled: true },
-  { code: 'en-US', label: 'Ingles (EUA)', flag: '🇺🇸', enabled: true },
-  { code: 'es-ES', label: 'Espanhol (Espanha)', flag: '🇪🇸', enabled: false },
-  { code: 'fr-FR', label: 'Frances (Franca)', flag: '🇫🇷', enabled: false },
-  { code: 'de-DE', label: 'Alemao (Alemanha)', flag: '🇩🇪', enabled: false },
-  { code: 'it-IT', label: 'Italiano (Italia)', flag: '🇮🇹', enabled: false },
-  { code: 'ja-JP', label: 'Japones (Japao)', flag: '🇯🇵', enabled: false },
-  { code: 'zh-CN', label: 'Chines (Simplificado)', flag: '🇨🇳', enabled: false },
-];
-
-const timezones = [
-  { value: 'America/Sao_Paulo', label: 'America/Sao_Paulo (GMT-3)' },
-  { value: 'America/New_York', label: 'America/New_York (GMT-5)' },
-  { value: 'America/Chicago', label: 'America/Chicago (GMT-6)' },
-  { value: 'America/Denver', label: 'America/Denver (GMT-7)' },
-  { value: 'America/Los_Angeles', label: 'America/Los_Angeles (GMT-8)' },
-  { value: 'Europe/London', label: 'Europe/London (GMT+0)' },
-  { value: 'Europe/Paris', label: 'Europe/Paris (GMT+1)' },
-  { value: 'Europe/Berlin', label: 'Europe/Berlin (GMT+1)' },
-  { value: 'Asia/Tokyo', label: 'Asia/Tokyo (GMT+9)' },
-  { value: 'Asia/Shanghai', label: 'Asia/Shanghai (GMT+8)' },
-  { value: 'Australia/Sydney', label: 'Australia/Sydney (GMT+11)' },
-];
-
-const dateFormats = [
-  { value: 'DD/MM/YYYY', label: 'DD/MM/YYYY', example: '14/02/2026' },
-  { value: 'MM/DD/YYYY', label: 'MM/DD/YYYY', example: '02/14/2026' },
-  { value: 'YYYY-MM-DD', label: 'YYYY-MM-DD', example: '2026-02-14' },
-  { value: 'DD.MM.YYYY', label: 'DD.MM.YYYY', example: '14.02.2026' },
-  { value: 'DD-MM-YYYY', label: 'DD-MM-YYYY', example: '14-02-2026' },
-];
-
-const timeFormats = [
-  { value: 'HH:mm', label: '24 horas', example: '14:30' },
-  { value: 'hh:mm A', label: '12 horas', example: '02:30 PM' },
-  { value: 'HH:mm:ss', label: '24 horas com segundos', example: '14:30:45' },
-  {
-    value: 'hh:mm:ss A',
-    label: '12 horas com segundos',
-    example: '02:30:45 PM',
-  },
-];
-
-export default function LocaleConfig() {
-  const [languages, setLanguages] = useState<Language[]>(availableLanguages);
-  const [defaultLang, setDefaultLang] = useState('pt-BR');
-  const [timezone, setTimezone] = useState('America/Sao_Paulo');
-  const [dateFormat, setDateFormat] = useState('DD/MM/YYYY');
-  const [timeFormat, setTimeFormat] = useState('HH:mm');
-  const [autoDetect, setAutoDetect] = useState(true);
-
-  const enabledLanguages = languages.filter((l) => l.enabled);
-
-  function toggleLanguage(code: string) {
-    setLanguages((prev) =>
-      prev.map((l) => {
-        if (l.code === code) {
-          if (l.enabled && l.code === defaultLang) return l;
-          return { ...l, enabled: !l.enabled };
-        }
-        return l;
-      })
-    );
-  }
-
-  return (
-    <Card className="h-full">
-      <CardHeader>
-        <div className="flex items-center justify-between">
-          <div className="flex items-center gap-3">
-            <div className="flex h-10 w-10 items-center justify-center rounded-lg bg-indigo-50">
-              <Globe className="h-5 w-5 text-indigo-600" />
-            </div>
-            <div>
-              <CardTitle className="text-base">Localizacao</CardTitle>
-              <CardDescription>
-                Idiomas, fuso horario e formatos regionais
-              </CardDescription>
-            </div>
-          </div>
-          <Badge variant="secondary" className="bg-indigo-50 text-indigo-700">
-            {enabledLanguages.length} idioma
-            {enabledLanguages.length !== 1 ? 's' : ''}
-          </Badge>
-        </div>
-      </CardHeader>
-      <CardContent className="space-y-6">
-        {/* Languages */}
-        <div className="space-y-3">
-          <div className="flex items-center gap-2">
-            <Type className="h-4 w-4 text-muted-foreground" />
-            <Label className="text-sm font-medium">Idiomas habilitados</Label>
-          </div>
-          <div className="grid grid-cols-2 gap-2">
-            {languages.map((lang) => (
-              <label
-                key={lang.code}
-                className={`flex cursor-pointer items-center gap-3 rounded-lg border p-3 transition-colors ${
-                  lang.enabled
-                    ? 'border-foreground/20 bg-foreground/2'
-                    : 'border-border hover:border-foreground/10'
-                }`}
-              >
-                <Checkbox
-                  checked={lang.enabled}
-                  onCheckedChange={() => toggleLanguage(lang.code)}
-                  disabled={lang.enabled && lang.code === defaultLang}
-                />
-                <span className="text-base leading-none">{lang.flag}</span>
-                <div className="flex flex-1 flex-col">
-                  <span className="text-sm font-medium">{lang.label}</span>
-                  <span className="text-xs text-muted-foreground">
-                    {lang.code}
-                  </span>
-                </div>
-                {lang.code === defaultLang && (
-                  <Badge variant="outline" className="text-[10px] h-5">
-                    Padrao
-                  </Badge>
-                )}
-              </label>
-            ))}
-          </div>
-        </div>
-
-        {/* Default Language */}
-        <div className="space-y-2">
-          <Label>Idioma padrao</Label>
-          <Select value={defaultLang} onValueChange={setDefaultLang}>
-            <SelectTrigger>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              {enabledLanguages.map((lang) => (
-                <SelectItem key={lang.code} value={lang.code}>
-                  <span className="flex items-center gap-2">
-                    <span>{lang.flag}</span>
-                    <span>{lang.label}</span>
-                  </span>
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-          <p className="text-xs text-muted-foreground">
-            Idioma exibido quando o idioma do usuario nao esta disponivel.
-          </p>
-        </div>
-
-        {/* Timezone */}
-        <div className="space-y-2">
-          <div className="flex items-center gap-2">
-            <Clock className="h-4 w-4 text-muted-foreground" />
-            <Label>Fuso horario do sistema</Label>
-          </div>
-          <Select value={timezone} onValueChange={setTimezone}>
-            <SelectTrigger>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              {timezones.map((tz) => (
-                <SelectItem key={tz.value} value={tz.value}>
-                  {tz.label}
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        </div>
-
-        {/* Date & Time Formats */}
-        <div className="grid gap-4 sm:grid-cols-2">
-          <div className="space-y-2">
-            <div className="flex items-center gap-2">
-              <Calendar className="h-4 w-4 text-muted-foreground" />
-              <Label>Formato de data</Label>
-            </div>
-            <Select value={dateFormat} onValueChange={setDateFormat}>
-              <SelectTrigger>
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                {dateFormats.map((df) => (
-                  <SelectItem key={df.value} value={df.value}>
-                    <span className="flex items-center gap-2">
-                      <span className="font-mono text-xs">{df.value}</span>
-                      <span className="text-muted-foreground">
-                        {'('}
-                        {df.example}
-                        {')'}
-                      </span>
-                    </span>
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
-          </div>
-          <div className="space-y-2">
-            <div className="flex items-center gap-2">
-              <Clock className="h-4 w-4 text-muted-foreground" />
-              <Label>Formato de hora</Label>
-            </div>
-            <Select value={timeFormat} onValueChange={setTimeFormat}>
-              <SelectTrigger>
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                {timeFormats.map((tf) => (
-                  <SelectItem key={tf.value} value={tf.value}>
-                    <span className="flex items-center gap-2">
-                      <span>{tf.label}</span>
-                      <span className="text-muted-foreground font-mono text-xs">
-                        {'('}
-                        {tf.example}
-                        {')'}
-                      </span>
-                    </span>
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
-          </div>
-        </div>
-
-        {/* Preview */}
-        <div className="rounded-lg border bg-muted/50 p-4">
-          <p className="mb-2 text-xs font-medium text-muted-foreground uppercase tracking-wider">
-            Pre-visualizacao
-          </p>
-          <div className="flex flex-wrap gap-x-6 gap-y-1 text-sm">
-            <span>
-              <span className="text-muted-foreground">Data: </span>
-              <span className="font-medium font-mono">
-                {dateFormats.find((d) => d.value === dateFormat)?.example}
-              </span>
-            </span>
-            <span>
-              <span className="text-muted-foreground">Hora: </span>
-              <span className="font-medium font-mono">
-                {timeFormats.find((t) => t.value === timeFormat)?.example}
-              </span>
-            </span>
-            <span>
-              <span className="text-muted-foreground">Fuso: </span>
-              <span className="font-medium font-mono">
-                {
-                  timezones
-                    .find((t) => t.value === timezone)
-                    ?.label.split(' ')[0]
-                }
-              </span>
-            </span>
-          </div>
-        </div>
-
-        {/* Actions */}
-        <div className="flex items-center justify-between border-t pt-4">
-          <div className="flex items-center gap-2">
-            <Switch
-              id="auto-detect-lang"
-              checked={autoDetect}
-              onCheckedChange={setAutoDetect}
-            />
-            <Label
-              htmlFor="auto-detect-lang"
-              className="text-sm text-muted-foreground"
-            >
-              Detectar idioma do navegador
-            </Label>
-          </div>
-          <Button size="sm">
-            <CheckCircle2 className="mr-1.5 h-3.5 w-3.5" />
-            Salvar
-          </Button>
-        </div>
-      </CardContent>
-    </Card>
-  );
-}