plss/functions/https/postGeneratePreview.js at d2ee592b661c80464afdd49cf9d4784941d5dfcb · agrc/plss · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import { getFirestore } from 'firebase-admin/firestore';
import { getStorage } from 'firebase-admin/storage';
import { https, logger } from 'firebase-functions/v1';
import {
  createPdfDocument,
  generatePdfDefinition,
  getPdfAssets,
} from '../pdfHelpers.js';
import { validateNewSubmission } from './postCorner.js';
import { safelyInitializeApp } from '../firebase.js';

const config = safelyInitializeApp();
const bucket = getStorage().bucket(config.storageBucket);
const db = getFirestore();
const oneDay = 1000 * 60 * 60 * 24;

export const generatePreview = async (data, auth) => {
  try {
    const result = await validateNewSubmission(data);
    logger.debug('validation result', result, {
      structuredData: true,
    });
  } catch (error) {
    logger.error('validation error', error, {
      structuredData: true,
    });

    throw new https.HttpsError(
      'invalid-argument',
      'pdf preview data is invalid',
      error,
    );
  }

  let surveyor = {
    name: auth.token.name,
    license: '',
    seal: '',
  };

  try {
    logger.debug('getting surveyor data', auth.uid, {
      structuredData: true,
    });

    const snapshot = await db.collection('submitters').doc(auth.uid).get();

    const { license, seal } = snapshot.data();

    surveyor.seal = seal;
    surveyor.license = license;
  } catch (error) {
    logger.error(
      'error fetching surveyor license. using empty string',
      auth.uid,
      error,
      {
        structuredData: true,
      },
    );
  }

  const { images, pdfs } = await getPdfAssets(
    bucket,
    data.images,
    surveyor.seal,
  );

  const definition = generatePdfDefinition(data, surveyor, images, true);

  const fileName = `submitters/${auth.uid}/new/${data.blmPointId}/preview.pdf`;
  const file = bucket.file(fileName);

  try {
    let pdf = await createPdfDocument(definition, pdfs);

    await file.save(pdf);
    await file.setMetadata({
      contentType: 'application/pdf',
      contentDisposition: 'inline',
    });
  } catch (error) {
    logger.error('error generating preview', error, data, {
      structuredData: true,
    });

    throw new https.HttpsError(
      'internal',
      'There was a problem creating the pdf',
    );
  }

  const record = {
    created_at: new Date(),
    id: data.blmPointId,
    preview: fileName,
    ttl: new Date(Date.now() + oneDay),
  };

  try {
    logger.debug('updating firestore', record, {
      structuredData: true,
    });

    await db
      .collection('previews')
      .doc(auth.uid)
      .collection('documents')
      .add(record);
  } catch (error) {
    logger.error(
      'error storing preview record. you will need to clean up the storage',
      fileName,
      error,
      {
        structuredData: true,
      },
    );
  }

  return fileName;
};