Backend do Registro de Caso de Investigador Privado

Modelo de Backend do Registro de Caso de Investigador Privado
Arquivos de Caso, Itens de Evidência e Cobrança

Q: Como as equipes de registro de casos de investigadores privados devem dividir as responsabilidades sem vazar dados entre os papéis?

É um esquema e API BaaS para trabalho investigativo: arquivos de casos, registros de evidências, notas de vigilância e entradas de cobrança de clientes.

Q: Quais fluxos de trabalho de registro de casos de investigadores privados se beneficiam mais de tarefas estruturadas em vez de notas livres?

Inclui User, CaseFile, EvidenceItem, SurveillanceNote e BillingEntry, além de um diagrama ER, sandbox de API e um prompt de Agente de IA.

Q: Qual é a melhor maneira de adicionar campos de relatório de registro de casos de investigadores privados sem desacelerar o trabalho diário?

Back4app fornece banco de dados gerenciado, autenticação, consultas em tempo real e esquema flexível para que você possa registrar evidências e notas de vigilância sem rodar seu próprio backend.

Q: Como faço para executar consultas para arquivos de casos e notas com Flutter?

Use as classes CaseFile e SurveillanceNote para consultar investigações abertas e notas de vigilância recentes através do SDK Back4app.

Q: Como gerencio o acesso ao registro de casos de investigador privado com Next.js Server Actions?

Use uma ação de servidor para criar um objeto Parse para EvidenceItem com um ponteiro CaseFile e validação para os campos evidenceTag, storageUrl e collectedAt. Opcionalmente, imponha a regra no Cloud Code.

Q: O React Native pode armazenar logs de casos offline?

Sim. Ative o Local Datastore e fixe os resultados de CaseFile, EvidenceItem e SurveillanceNote para que os investigadores possam revisar os registros sem conectividade.

Q: Como posso evitar edições não autorizadas de evidências?

No Cloud Code beforeSave para EvidenceItem, aplique verificações de investigador designado e rejeite gravações que não pertencem ao CaseFile.

Q: Qual é a melhor maneira de mostrar o tempo faturável no Android?

Consultas nas classes BillingEntry e CaseFile para exibir horas, taxa, valor e workType para cada investigação.

Um backend de registro de caso de investigador privado pronto para produção em Back4app com classes de Arquivo de Caso, Item de Evidência, Nota de Vigilância e Entrada de Cobrança. Acompanhe o histórico do caso, preserve as etiquetas de evidência e mantenha a cobrança vinculada ao mesmo arquivo.

Construa com Agente de IA Escolha Sua Tecnologia

Principais Conclusões do Registro de Casos

Este modelo fornece um backend de registro de casos de detetive particular com registros de CaseFile, EvidenceItem, SurveillanceNote e BillingEntry, para que a equipe possa manter um arquivo cronológico limpo.

Rastreamento de evidências caso a caso — Modelo de EvidenceItem com campos evidenceTag, evidenceType, storageUrl e isSealed para cada item.
Cronologia de notas de vigilância — Mantenha as entradas de SurveillanceNote vinculadas a um CaseFile com noteTime, localização, resumo e detalhes.
Registros de faturamento do cliente — Use BillingEntry para capturar horas, tarifa, valor, tipoDeTrabalho e aprovadoPor por CaseFile.
Acesso ciente de função — Restringir o acesso a CaseFile, EvidenceItem e BillingEntry com regras de ACL e CLP.
Paridade de API web e móvel — Atenda React, Flutter, Next.js e aplicativos nativos através dos mesmos endpoints REST e GraphQL.

O que é o modelo de registro de casos de detetive particular?

Se a coleta do registro de casos de detetive particular for desorganizada, tudo a montante sofre — uma captura limpa na entrada economiza horas de reconstrução depois. Clareza vence heroicidades. Este modelo modela CaseFile, EvidenceItem, SurveillanceNote e BillingEntry com acesso baseado em função em Back4app, para que cada membro da equipe do registro de casos de detetive particular veja a parte do pipeline que possui.

Melhor para:

Gestão de casos de detetive particularSistemas de registro de evidênciasFerramentas de captura de notas de vigilânciaRastreador de cobrança de clientesLançamentos de MVPEquipes selecionando BaaS para fluxos de trabalho de PI

O que você obtém no modelo de Registro de Casos de Investigador Privado

No registro de casos de investigador privado, as conversas mais difíceis começam com “qual número é oficial?” — um sinal de que o backend ainda não é autoritativo.

Cada cartão de tecnologia aqui mapeia para o mesmo modelo de CaseFile, EvidenceItem e SurveillanceNote — escolha uma pilha sem renegociar seu contrato de backend.

Recursos principais do log de caso de PI

Todo cartão de tecnologia neste hub utiliza o mesmo esquema de backend do registro de casos com User, CaseFile, EvidenceItem, SurveillanceNote e BillingEntry.

Gerenciamento de arquivos de caso

CaseFile armazena caseNumber, clientName, status, assignedInvestigator e billingRate.

Registro de evidências

EvidenceItem vincula-se ao CaseFile e captura evidenceTag, evidenceType, storageUrl e isSealed.

Notas de vigilância

SurveillanceNote armazena noteTime, location, summary, detail e followUpNeeded para cada período de vigilância.

Entradas de faturamento do cliente

BillingEntry captura entryDate, hours, rate, amount, workType e approvedBy.

Por que construir seu log de caso de PI com Back4app?

Back4app fornece as classes de dados e controles de acesso para manter arquivos de caso, evidências, notas e registros de faturamento organizados, enquanto a equipe se concentra no trabalho de campo.

•CaseFile e EvidenceItem permanecem vinculados: Armazene cada EvidenceItem contra um CaseFile para que fotos, recibos e detalhes da cadeia de custódia permaneçam anexados à investigação correta.
•As linhas do tempo de SurveillanceNote são mais fáceis de ler: Um campo noteTime em SurveillanceNote torna o log de vigilância ordenável por hora de observação em vez de adivinhação em texto livre.
•BillingEntry corresponde ao registro de investigação: Capture horas, tarifa, valor e workType em BillingEntry para conectar o tempo de campo com a cobrança do cliente.

Construa o log de casos uma vez e reutilize o mesmo contrato de backend em web, mobile e painéis de investigadores.

Benefícios do Registro de Casos do PI

Um backend de registro de casos que mantém notas de investigação e faturamento organizadas desde a primeira entrada.

Rastros de evidência mais limpos

Os registros EvidenceItem preservam evidenceTag, evidenceType, storageUrl e collectedAt para cada item.

Histórico de vigilância legível

As entradas SurveillanceNote ligadas a um CaseFile fornecem um registro de campo ordenado por tempo com localização, resumo e detalhes.

Faturamento que segue o caso

BillingEntry mantém horas, taxa, valor e workType conectados ao mesmo CaseFile de onde o trabalho veio.

Controle de acesso para arquivos sensíveis

Use ACL e CLP para que apenas investigadores designados possam editar um CaseFile ou adicionar linhas EvidenceItem.

Acesso entre dispositivos a logs de casos

APIs REST e GraphQL permitem que painéis da web, aplicativos móveis de campo e ferramentas de faturamento de back-office leiam os mesmos dados de CaseFile.

Reutilização rápida de esquema

Comece com Usuário, Caso, Item de Evidência, Nota de Vigilância e Registro de Cobrança em vez de construir registros de caso campo por campo.

Pronto para lançar o seu registro de caso de investigador particular?

Deixe o agente de IA do Back4app estruturar o backend do seu registro de caso e gerar fluxos de Caso, Item de Evidência, Nota de Vigilância e Registro de Cobrança a partir de um prompt.

Construa com agente de IA Experimente o Sandbox da API

Grátis para começar — 50 prompts de agente de IA/mês, sem cartão de crédito necessário

Pilha de Tecnologia para Registro de Caso

Tudo incluído neste template de log de casos de investigador privado.

Frontend

13+ tecnologias

Backend

Back4app

Banco de dados

MongoDB

Autenticação

Autenticação e sessões integradas

API

REST e GraphQL

Em tempo real

Live Queries

Diagrama ER de Caso

Modelo de relacionamento de entidades para o esquema de backend do registro de casos do investigador privado.

Diagrama ER

Ver fonte do diagrama

Mermaid

erDiagram
    User ||--o{ CaseFile : "assignedInvestigator"
    User ||--o{ EvidenceItem : "collectedBy"
    User ||--o{ SurveillanceNote : "observer"
    User ||--o{ BillingEntry : "approvedBy"
    CaseFile ||--o{ EvidenceItem : "caseFile"
    CaseFile ||--o{ SurveillanceNote : "caseFile"
    CaseFile ||--o{ BillingEntry : "caseFile"

    User {
        String objectId PK
        String username
        String email
        String password
        String role
        Date createdAt
        Date updatedAt
    }

    CaseFile {
        String objectId PK
        String caseNumber
        String clientName
        String status
        String assignedInvestigatorId FK
        Number billingRate
        Date openedAt
        Date closedAt
        Date createdAt
        Date updatedAt
    }

    EvidenceItem {
        String objectId PK
        String caseFileId FK
        String evidenceTag
        String evidenceType
        String storageUrl
        String collectedById FK
        Date collectedAt
        String locationLabel
        Boolean isSealed
        Date createdAt
        Date updatedAt
    }

    SurveillanceNote {
        String objectId PK
        String caseFileId FK
        Date noteTime
        String observerId FK
        String location
        String summary
        String detail
        Boolean followUpNeeded
        Date createdAt
        Date updatedAt
    }

    BillingEntry {
        String objectId PK
        String caseFileId FK
        Date entryDate
        Number hours
        Number rate
        Number amount
        String workType
        String approvedById FK
        Date createdAt
        Date updatedAt
    }

Fluxo de Sincronização de Casos

Fluxo típico de tempo de execução para login, carregamento de CaseFile, uploads de EvidenceItem, criação de SurveillanceNote e revisão de BillingEntry.

Diagrama ER

Ver fonte do diagrama

Mermaid

sequenceDiagram
  participant User
  participant App as Private Investigator Case Log App
  participant Back4app as Back4app Cloud

  User->>App: Sign in to the case log
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Open today's CaseFile list
  App->>Back4app: GET /classes/CaseFile?order=-openedAt
  Back4app-->>App: CaseFile rows

  User->>App: Add an EvidenceItem or SurveillanceNote
  App->>Back4app: POST /classes/EvidenceItem or /classes/SurveillanceNote
  Back4app-->>App: Saved objectId and timestamps

  User->>App: Review BillingEntry totals for a CaseFile
  App->>Back4app: GET /classes/BillingEntry?include=caseFile
  Back4app-->>App: BillingEntry list

  App->>Back4app: Live update case activity
  Back4app-->>App: CaseFile, EvidenceItem, SurveillanceNote changes

Dicionário de Campos

Referência completa a nível de campo para cada classe no esquema de registro de casos de investigador particular.

Campo	Tipo	Descrição	Requerido
objectId	String	Auto-generated unique identifier	Automático
username	String	User login name
email	String	User email address
password	String	Hashed password (write-only)
role	String	Staff role such as investigator, admin, or billing
createdAt	Date	Auto-generated creation timestamp	Automático
updatedAt	Date	Auto-generated last-update timestamp	Automático

7 campos em User

Segurança e Permissões do Caso

Como a estratégia de ACL e CLP protege usuários, arquivos de caso, itens de evidência, notas e entradas de cobrança.

Controles do investigador designado

Somente o Usuário designado ou o proprietário do caso pode atualizar um Arquivo de Caso, adicionar evidência ou revisar detalhes de cobrança.

Verificações de integridade da evidência

Use validação de Cloud Code para que as linhas de Item de Evidência exijam um ponteiro de Arquivo de Caso, storageUrl e coleta por trail.

Acesso de leitura com escopo

Restringir anotações de casos e entradas de cobrança ao pessoal que trabalha nesse arquivo; entradas sensíveis não devem ser expostas amplamente.

Esquema JSON

Definição de esquema JSON bruto pronta para copiar para Back4app ou usar como referência de implementação.

JSON

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "CaseFile",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caseNumber": {
          "type": "String",
          "required": true
        },
        "clientName": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "assignedInvestigator": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "billingRate": {
          "type": "Number",
          "required": true
        },
        "openedAt": {
          "type": "Date",
          "required": true
        },
        "closedAt": {
          "type": "Date",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "EvidenceItem",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caseFile": {
          "type": "Pointer",
          "required": true,
          "targetClass": "CaseFile"
        },
        "evidenceTag": {
          "type": "String",
          "required": true
        },
        "evidenceType": {
          "type": "String",
          "required": true
        },
        "storageUrl": {
          "type": "String",
          "required": true
        },
        "collectedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "collectedAt": {
          "type": "Date",
          "required": true
        },
        "locationLabel": {
          "type": "String",
          "required": false
        },
        "isSealed": {
          "type": "Boolean",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "SurveillanceNote",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caseFile": {
          "type": "Pointer",
          "required": true,
          "targetClass": "CaseFile"
        },
        "noteTime": {
          "type": "Date",
          "required": true
        },
        "observer": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "location": {
          "type": "String",
          "required": true
        },
        "summary": {
          "type": "String",
          "required": true
        },
        "detail": {
          "type": "String",
          "required": true
        },
        "followUpNeeded": {
          "type": "Boolean",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "BillingEntry",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caseFile": {
          "type": "Pointer",
          "required": true,
          "targetClass": "CaseFile"
        },
        "entryDate": {
          "type": "Date",
          "required": true
        },
        "hours": {
          "type": "Number",
          "required": true
        },
        "rate": {
          "type": "Number",
          "required": true
        },
        "amount": {
          "type": "Number",
          "required": true
        },
        "workType": {
          "type": "String",
          "required": true
        },
        "approvedBy": {
          "type": "Pointer",
          "required": false,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construir com o Agente de IA

Use o Agente de IA Back4app para gerar um aplicativo real de registro de caso de investigador privado a partir deste modelo, incluindo frontend, backend, autenticação, e fluxos de CaseFile, EvidenceItem, SurveillanceNote e BillingEntry.

Agente de IA Back4app

Pronto para construir

Crie um backend de aplicativo de registro de casos de investigador particular no Back4app com este esquema e comportamento exatos.

Esquema:
1. Usuário (use o embutido Back4app): nome de usuário, e-mail, senha, papel; objectId, createdAt, updatedAt (sistema).
2. CasoArquivo: numeroCaso (String, obrigatório), nomeCliente (String, obrigatório), status (String, obrigatório), investigadorDesignado (Ponteiro para Usuário, obrigatório), taxaCobrança (Número, obrigatório), abertoEm (Data, obrigatório), fechadoEm (Data, opcional); objectId, createdAt, updatedAt (sistema).
3. ItemEvidência: casoArquivo (Ponteiro para CasoArquivo, obrigatório), etiquetaEvidência (String, obrigatório), tipoEvidência (String, obrigatório), urlArmazenamento (String, obrigatório), coletadoPor (Ponteiro para Usuário, obrigatório), coletadoEm (Data, obrigatório), etiquetaLocal (String, opcional), estáSelado (Booleano, obrigatório); objectId, createdAt, updatedAt (sistema).
4. NotaVigilância: casoArquivo (Ponteiro para CasoArquivo, obrigatório), tempoNota (Data, obrigatório), observador (Ponteiro para Usuário, obrigatório), localização (String, obrigatório), resumo (String, obrigatório), detalhe (String, obrigatório), acompanhamentoNecessário (Booleano, obrigatório); objectId, createdAt, updatedAt (sistema).
5. EntradaCobrança: casoArquivo (Ponteiro para CasoArquivo, obrigatório), dataEntrada (Data, obrigatório), horas (Número, obrigatório), taxa (Número, obrigatório), valor (Número, obrigatório), tipoTrabalho (String, obrigatório), aprovadoPor (Ponteiro para Usuário, opcional); objectId, createdAt, updatedAt (sistema).

Segurança:
- Limitar a visibilidade de CasoArquivo a investigadores designados e equipe de cobrança.
- Registros de ItemEvidência devem ser graváveis apenas por equipe com acesso ao caso.
- Entradas de NotaVigilância devem preservar a história cronológica.
- Totais de EntradaCobrança são editáveis pela equipe aprovada para cobranças.

Auth:
- Cadastro, login, logout.

Comportamento:
- listar arquivos de casos abertos, criar entradas de evidência, adicionar notas de vigilância, calcular entradas de cobrança e mostrar atualizações ao vivo para atividade de caso.

Entrega:
- aplicativo Back4app com esquema, ACLs, CLPs; frontend para gerenciamento de casos, registro de evidências, notas de vigilância e cobrança de clientes.

Pressione o botão abaixo para abrir o Agente com este prompt de modelo pré-preenchido.

Este é o prompt base sem um sufixo de tecnologia. Você pode adaptar a pilha de frontend gerada depois.

Implantar em minutos50 prompts gratuitos / mêsNão é necessário cartão de crédito

Sandbox API

Experimente os endpoints REST e GraphQL contra o esquema de registro de casos de investigador particular. As respostas usam dados simulados e não exigem uma conta Back4app.

Carregando playground…

Usa o mesmo esquema que este template.

Escolha Sua Tecnologia

Expanda cada cartão para ver como integrar CaseFile, EvidenceItem e SurveillanceNote com sua pilha escolhida.

O que você recebe com cada tecnologia

Cada pilha usa o mesmo esquema de log de caso de detetive particular e contratos de API.

Estrutura unificada de log de caso

Gerencie registros de Usuário, CaseFile, EvidenceItem, SurveillanceNote e BillingEntry com um esquema consistente.

Registro de evidências para trabalho de PI

Registre evidenceTag, evidenceType, storageUrl e collectedAt para cada EvidenceItem.

Linhas do tempo de notas de vigilância

Capture a localização, resumo, detalhe e horário de nota para revisão de trabalho de campo.

Registros de cobrança de cliente

Rastrear horas, tarifa, valor e tipo de trabalho por arquivo de caso.

APIs REST/GraphQL para investigações

Integre ferramentas web, móveis e de escritório com um único contrato de backend.

Fluxo de trabalho de caso extensível

Adicione novas classes ou campos à medida que seu processo de investigação muda.

Comparação de Tecnologia de Investigador Privado

Compare a velocidade de configuração, estilo de SDK e suporte a IA em todas as tecnologias suportadas.

Framework	Tempo de Configuração	Benefício do Registro de Caso PI	Tipo de SDK	Suporte de IA
Flutter	Cerca de 5 min	Base de código única para registros de casos de investigadores em dispositivos móveis e na web.	SDK Digitado	Completo
React	Menos de 5 minutos	Painel web rápido para arquivos de casos e evidências.	SDK Digitado	Completo
Nativo React	~3–7 min	Aplicativo móvel multiplataforma para anotações de campo e captura de evidências.	SDK Digitado	Completo
Next.js	Configuração rápida (5 min)	Portal de gerenciamento de casos renderizado no servidor para investigadores.	SDK Digitado	Completo
JavaScript	~3–5 min	Integração web leve para registros de PI.	SDK Digitado	Completo
Android	Cerca de 5 min	Aplicativo nativo Android para notas de vigilância de campo.	SDK Digitado	Completo
iOS	Menos de 5 minutos	Aplicativo nativo iOS para registro de evidências.	SDK Digitado	Completo
Vue	~3–7 min	Interface web Reactive para revisão de registro de casos.	SDK Digitado	Completo
Angular	Configuração rápida (5 min)	Aplicativo web corporativo para arquivos de casos e cobrança.	SDK Digitado	Completo
GraphQL	Menos de 2 minutos	API flexível GraphQL para dados de casos aninhados.	API GraphQL	Completo
REST API	Configuração rápida (2 min)	Integração REST API para registros de casos de PI.	REST API	Completo
PHP	~3 min	Backend PHP do lado do servidor para fluxos de trabalho de arquivos de casos.	REST API	Completo
.NET	~3–7 min	backend do .NET para investigações e faturamento.	SDK Digitado	Completo

O tempo de configuração reflete a duração esperada desde a inicialização do projeto até o primeiro registro de caso ou consulta de evidência usando este esquema de modelo.

FAQ do Registro de Casos de PI

Perguntas comuns sobre como construir um backend de registro de casos de investigador particular com este modelo.

Como as equipes de registro de casos de investigadores privados devem dividir as responsabilidades sem vazar dados entre os papéis?

Quais fluxos de trabalho de registro de casos de investigadores privados se beneficiam mais de tarefas estruturadas em vez de notas livres?

Qual é a melhor maneira de adicionar campos de relatório de registro de casos de investigadores privados sem desacelerar o trabalho diário?

Como faço para executar consultas para arquivos de casos e notas com Flutter?

Como gerencio o acesso ao registro de casos de investigador privado com Next.js Server Actions?

O React Native pode armazenar logs de casos offline?

Como posso evitar edições não autorizadas de evidências?

Qual é a melhor maneira de mostrar o tempo faturável no Android?

Confiável por desenvolvedores em todo o mundo

Junte-se a equipes que entregam produtos de registro de casos de investigadores privados mais rapidamente com os templates do Back4app

Pronto para Construir Seu Aplicativo de Registro de Casos de Investigador Privado?

Comece seu projeto de registro de casos de investigador privado em minutos. Não é necessário cartão de crédito.

Escolha Tecnologia

Modelo de Backend do Registro de Caso de Investigador PrivadoArquivos de Caso, Itens de Evidência e Cobrança