@cryptotaxi247 / CoPilot / commits / 0026e00a

split models into individual files for modularity

Taylor committed Jul 11, 2023 at 07:30 UTC 0026e00a25f56312a049ce58729fd383a9766fc9
5 files changed +304 -128
backend/app/models/artifacts.py new
+35
@@ -0,0 +1,35 @@
1 +from datetime import datetime
2 +
3 +from app import db
4 +from app import ma
5 +from sqlalchemy.dialects.postgresql import TEXT # Add this line
6 +
7 +# Class for artifacts collected which stores the artifact name, artificat results (json), hostname
8 +# Path: backend\app\models.py
9 +class Artifact(db.Model):
10 + id = db.Column(db.Integer, primary_key=True)
11 + artifact_name = db.Column(db.String(100))
12 + artifact_results = db.Column(TEXT)
13 + hostname = db.Column(db.String(100))
14 +
15 + def __init__(self, artifact_name, artifact_results, hostname):
16 + self.artifact_name = artifact_name
17 + self.artifact_results = artifact_results
18 + self.hostname = hostname
19 +
20 + def __repr__(self):
21 + return f"<Artifact {self.artifact_name}>"
22 +
23 +
24 +class ArtifactSchema(ma.Schema):
25 + class Meta:
26 + fields = (
27 + "id",
28 + "artifact_name",
29 + "artifact_results",
30 + "hostname",
31 + )
32 +
33 +
34 +artifact_schema = ArtifactSchema()
35 +artifacts_schema = ArtifactSchema(many=True)
backend/app/models/cases.py new
+34
@@ -0,0 +1,34 @@
1 +from datetime import datetime
2 +
3 +from app import db
4 +from app import ma
5 +
6 +# Class for cases which stores the case ID, case name, list of agents
7 +# Path: backend\app\models.py
8 +class Case(db.Model):
9 + id = db.Column(db.Integer, primary_key=True)
10 + case_id = db.Column(db.Integer)
11 + case_name = db.Column(db.String(100))
12 + agents = db.Column(db.String(1000))
13 +
14 + def __init__(self, case_id, case_name, agents):
15 + self.case_id = case_id
16 + self.case_name = case_name
17 + self.agents = agents
18 +
19 + def __repr__(self):
20 + return f"<Case {self.case_id}>"
21 +
22 +
23 +class CaseSchema(ma.Schema):
24 + class Meta:
25 + fields = (
26 + "id",
27 + "case_id",
28 + "case_name",
29 + "agents",
30 + )
31 +
32 +
33 +case_schema = CaseSchema()
34 +cases_schema = CaseSchema(many=True)
backend/app/models/graylog.py new
+58
@@ -0,0 +1,58 @@
1 +from datetime import datetime
2 +
3 +from app import db
4 +from app import ma
5 +
6 +# Class for Graylog allocation which stores throughput metrics
7 +# Generate timestamp for each entry and invoke every 5 minutes.
8 +# Path: backend\app\models.py
9 +class GraylogMetricsAllocation(db.Model):
10 + id = db.Column(db.Integer, primary_key=True)
11 + input_usage = db.Column(db.Float)
12 + output_usage = db.Column(db.Float)
13 + processor_usage = db.Column(db.Float)
14 + input_1_sec_rate = db.Column(db.Float)
15 + output_1_sec_rate = db.Column(db.Float)
16 + total_input = db.Column(db.Float)
17 + total_output = db.Column(db.Float)
18 + timestamp = db.Column(db.DateTime, default=datetime.utcnow)
19 +
20 + def __init__(
21 + self,
22 + input_usage,
23 + output_usage,
24 + processor_usage,
25 + input_1_sec_rate,
26 + output_1_sec_rate,
27 + total_input,
28 + total_output,
29 + ):
30 + self.input_usage = input_usage
31 + self.output_usage = output_usage
32 + self.processor_usage = processor_usage
33 + self.input_1_sec_rate = input_1_sec_rate
34 + self.output_1_sec_rate = output_1_sec_rate
35 + self.total_input = total_input
36 + self.total_output = total_output
37 +
38 + def __repr__(self):
39 + return f"<GraylogMetricsAllocation {self.id}>"
40 +
41 +
42 +class GraylogMetricsAllocationSchema(ma.Schema):
43 + class Meta:
44 + fields = (
45 + "id",
46 + "input_usage",
47 + "output_usage",
48 + "processor_usage",
49 + "input_1_sec_rate",
50 + "output_1_sec_rate",
51 + "total_input",
52 + "total_output",
53 + "timestamp",
54 + )
55 +
56 +
57 +graylog_metrics_allocation_schema = GraylogMetricsAllocationSchema()
58 +graylog_metrics_allocations_schema = GraylogMetricsAllocationSchema(many=True)
backend/app/models/models.py
+127 -128
@@ -1,7 +1,6 @@
1 from datetime import datetime
2
3 from loguru import logger
4 -from sqlalchemy.dialects.postgresql import TEXT # Add this line
4
5 from app import db
6 from app import ma
@@ -150,162 +149,162 @@ connectors_schema = ConnectorsSchema(many=True)
149 # Class for Wazuh Indexer allocation which stores disk stats and the host.
150 # Generate timestamp for each entry and invoke every 5 minutes.
151 # Path: backend\app\models.py
153 -class WazuhIndexerAllocation(db.Model):
154 - id = db.Column(db.Integer, primary_key=True)
155 - node = db.Column(db.String(100))
156 - disk_used = db.Column(db.Float)
157 - disk_available = db.Column(db.Float)
158 - disk_total = db.Column(db.Float)
159 - disk_percent = db.Column(db.Float)
160 - timestamp = db.Column(db.DateTime, default=datetime.utcnow)
152 +# class WazuhIndexerAllocation(db.Model):
153 +# id = db.Column(db.Integer, primary_key=True)
154 +# node = db.Column(db.String(100))
155 +# disk_used = db.Column(db.Float)
156 +# disk_available = db.Column(db.Float)
157 +# disk_total = db.Column(db.Float)
158 +# disk_percent = db.Column(db.Float)
159 +# timestamp = db.Column(db.DateTime, default=datetime.utcnow)
160
162 - def __init__(
163 - self,
164 - node,
165 - disk_used,
166 - disk_available,
167 - disk_total,
168 - disk_percent,
169 - ):
170 - self.node = node
171 - self.disk_used = disk_used
172 - self.disk_available = disk_available
173 - self.disk_total = disk_total
174 - self.disk_percent = disk_percent
161 +# def __init__(
162 +# self,
163 +# node,
164 +# disk_used,
165 +# disk_available,
166 +# disk_total,
167 +# disk_percent,
168 +# ):
169 +# self.node = node
170 +# self.disk_used = disk_used
171 +# self.disk_available = disk_available
172 +# self.disk_total = disk_total
173 +# self.disk_percent = disk_percent
174
176 - def __repr__(self):
177 - return f"<WazuhIndexerAllocation {self.node}>"
175 +# def __repr__(self):
176 +# return f"<WazuhIndexerAllocation {self.node}>"
177
178
180 -class WazuhIndexerAllocationSchema(ma.Schema):
181 - class Meta:
182 - fields = (
183 - "id",
184 - "node",
185 - "disk_used",
186 - "disk_available",
187 - "disk_total",
188 - "disk_percent",
189 - "timestamp",
190 - )
179 +# class WazuhIndexerAllocationSchema(ma.Schema):
180 +# class Meta:
181 +# fields = (
182 +# "id",
183 +# "node",
184 +# "disk_used",
185 +# "disk_available",
186 +# "disk_total",
187 +# "disk_percent",
188 +# "timestamp",
189 +# )
190
191
193 -wazuh_indexer_allocation_schema = WazuhIndexerAllocationSchema()
194 -wazuh_indexer_allocations_schema = WazuhIndexerAllocationSchema(many=True)
192 +# wazuh_indexer_allocation_schema = WazuhIndexerAllocationSchema()
193 +# wazuh_indexer_allocations_schema = WazuhIndexerAllocationSchema(many=True)
194
195
197 -# Class for Graylog allocation which stores throughput metrics
198 -# Generate timestamp for each entry and invoke every 5 minutes.
199 -# Path: backend\app\models.py
200 -class GraylogMetricsAllocation(db.Model):
201 - id = db.Column(db.Integer, primary_key=True)
202 - input_usage = db.Column(db.Float)
203 - output_usage = db.Column(db.Float)
204 - processor_usage = db.Column(db.Float)
205 - input_1_sec_rate = db.Column(db.Float)
206 - output_1_sec_rate = db.Column(db.Float)
207 - total_input = db.Column(db.Float)
208 - total_output = db.Column(db.Float)
209 - timestamp = db.Column(db.DateTime, default=datetime.utcnow)
196 +# # Class for Graylog allocation which stores throughput metrics
197 +# # Generate timestamp for each entry and invoke every 5 minutes.
198 +# # Path: backend\app\models.py
199 +# class GraylogMetricsAllocation(db.Model):
200 +# id = db.Column(db.Integer, primary_key=True)
201 +# input_usage = db.Column(db.Float)
202 +# output_usage = db.Column(db.Float)
203 +# processor_usage = db.Column(db.Float)
204 +# input_1_sec_rate = db.Column(db.Float)
205 +# output_1_sec_rate = db.Column(db.Float)
206 +# total_input = db.Column(db.Float)
207 +# total_output = db.Column(db.Float)
208 +# timestamp = db.Column(db.DateTime, default=datetime.utcnow)
209
211 - def __init__(
212 - self,
213 - input_usage,
214 - output_usage,
215 - processor_usage,
216 - input_1_sec_rate,
217 - output_1_sec_rate,
218 - total_input,
219 - total_output,
220 - ):
221 - self.input_usage = input_usage
222 - self.output_usage = output_usage
223 - self.processor_usage = processor_usage
224 - self.input_1_sec_rate = input_1_sec_rate
225 - self.output_1_sec_rate = output_1_sec_rate
226 - self.total_input = total_input
227 - self.total_output = total_output
210 +# def __init__(
211 +# self,
212 +# input_usage,
213 +# output_usage,
214 +# processor_usage,
215 +# input_1_sec_rate,
216 +# output_1_sec_rate,
217 +# total_input,
218 +# total_output,
219 +# ):
220 +# self.input_usage = input_usage
221 +# self.output_usage = output_usage
222 +# self.processor_usage = processor_usage
223 +# self.input_1_sec_rate = input_1_sec_rate
224 +# self.output_1_sec_rate = output_1_sec_rate
225 +# self.total_input = total_input
226 +# self.total_output = total_output
227
229 - def __repr__(self):
230 - return f"<GraylogMetricsAllocation {self.id}>"
228 +# def __repr__(self):
229 +# return f"<GraylogMetricsAllocation {self.id}>"
230
231
233 -class GraylogMetricsAllocationSchema(ma.Schema):
234 - class Meta:
235 - fields = (
236 - "id",
237 - "input_usage",
238 - "output_usage",
239 - "processor_usage",
240 - "input_1_sec_rate",
241 - "output_1_sec_rate",
242 - "total_input",
243 - "total_output",
244 - "timestamp",
245 - )
232 +# class GraylogMetricsAllocationSchema(ma.Schema):
233 +# class Meta:
234 +# fields = (
235 +# "id",
236 +# "input_usage",
237 +# "output_usage",
238 +# "processor_usage",
239 +# "input_1_sec_rate",
240 +# "output_1_sec_rate",
241 +# "total_input",
242 +# "total_output",
243 +# "timestamp",
244 +# )
245
246
248 -graylog_metrics_allocation_schema = GraylogMetricsAllocationSchema()
249 -graylog_metrics_allocations_schema = GraylogMetricsAllocationSchema(many=True)
247 +# graylog_metrics_allocation_schema = GraylogMetricsAllocationSchema()
248 +# graylog_metrics_allocations_schema = GraylogMetricsAllocationSchema(many=True)
249
250
251 # Class for cases which stores the case ID, case name, list of agents
252 # Path: backend\app\models.py
254 -class Case(db.Model):
255 - id = db.Column(db.Integer, primary_key=True)
256 - case_id = db.Column(db.Integer)
257 - case_name = db.Column(db.String(100))
258 - agents = db.Column(db.String(1000))
253 +# class Case(db.Model):
254 +# id = db.Column(db.Integer, primary_key=True)
255 +# case_id = db.Column(db.Integer)
256 +# case_name = db.Column(db.String(100))
257 +# agents = db.Column(db.String(1000))
258
260 - def __init__(self, case_id, case_name, agents):
261 - self.case_id = case_id
262 - self.case_name = case_name
263 - self.agents = agents
259 +# def __init__(self, case_id, case_name, agents):
260 +# self.case_id = case_id
261 +# self.case_name = case_name
262 +# self.agents = agents
263
265 - def __repr__(self):
266 - return f"<Case {self.case_id}>"
264 +# def __repr__(self):
265 +# return f"<Case {self.case_id}>"
266
267
269 -class CaseSchema(ma.Schema):
270 - class Meta:
271 - fields = (
272 - "id",
273 - "case_id",
274 - "case_name",
275 - "agents",
276 - )
268 +# class CaseSchema(ma.Schema):
269 +# class Meta:
270 +# fields = (
271 +# "id",
272 +# "case_id",
273 +# "case_name",
274 +# "agents",
275 +# )
276
277
279 -case_schema = CaseSchema()
280 -cases_schema = CaseSchema(many=True)
278 +# case_schema = CaseSchema()
279 +# cases_schema = CaseSchema(many=True)
280
281
283 -# Class for artifacts collected which stores the artifact name, artificat results (json), hostname
284 -# Path: backend\app\models.py
285 -class Artifact(db.Model):
286 - id = db.Column(db.Integer, primary_key=True)
287 - artifact_name = db.Column(db.String(100))
288 - artifact_results = db.Column(TEXT)
289 - hostname = db.Column(db.String(100))
282 +# # Class for artifacts collected which stores the artifact name, artificat results (json), hostname
283 +# # Path: backend\app\models.py
284 +# class Artifact(db.Model):
285 +# id = db.Column(db.Integer, primary_key=True)
286 +# artifact_name = db.Column(db.String(100))
287 +# artifact_results = db.Column(TEXT)
288 +# hostname = db.Column(db.String(100))
289
291 - def __init__(self, artifact_name, artifact_results, hostname):
292 - self.artifact_name = artifact_name
293 - self.artifact_results = artifact_results
294 - self.hostname = hostname
290 +# def __init__(self, artifact_name, artifact_results, hostname):
291 +# self.artifact_name = artifact_name
292 +# self.artifact_results = artifact_results
293 +# self.hostname = hostname
294
296 - def __repr__(self):
297 - return f"<Artifact {self.artifact_name}>"
295 +# def __repr__(self):
296 +# return f"<Artifact {self.artifact_name}>"
297
298
300 -class ArtifactSchema(ma.Schema):
301 - class Meta:
302 - fields = (
303 - "id",
304 - "artifact_name",
305 - "artifact_results",
306 - "hostname",
307 - )
299 +# class ArtifactSchema(ma.Schema):
300 +# class Meta:
301 +# fields = (
302 +# "id",
303 +# "artifact_name",
304 +# "artifact_results",
305 +# "hostname",
306 +# )
307
308
310 -artifact_schema = ArtifactSchema()
311 -artifacts_schema = ArtifactSchema(many=True)
309 +# artifact_schema = ArtifactSchema()
310 +# artifacts_schema = ArtifactSchema(many=True)
backend/app/models/wazuh_indexer.py new
+50
@@ -0,0 +1,50 @@
1 +from datetime import datetime
2 +
3 +from app import db
4 +from app import ma
5 +
6 +# Class for Wazuh Indexer allocation which stores disk stats and the host.
7 +# Generate timestamp for each entry and invoke every 5 minutes.
8 +# Path: backend\app\models.py
9 +class WazuhIndexerAllocation(db.Model):
10 + id = db.Column(db.Integer, primary_key=True)
11 + node = db.Column(db.String(100))
12 + disk_used = db.Column(db.Float)
13 + disk_available = db.Column(db.Float)
14 + disk_total = db.Column(db.Float)
15 + disk_percent = db.Column(db.Float)
16 + timestamp = db.Column(db.DateTime, default=datetime.utcnow)
17 +
18 + def __init__(
19 + self,
20 + node,
21 + disk_used,
22 + disk_available,
23 + disk_total,
24 + disk_percent,
25 + ):
26 + self.node = node
27 + self.disk_used = disk_used
28 + self.disk_available = disk_available
29 + self.disk_total = disk_total
30 + self.disk_percent = disk_percent
31 +
32 + def __repr__(self):
33 + return f"<WazuhIndexerAllocation {self.node}>"
34 +
35 +
36 +class WazuhIndexerAllocationSchema(ma.Schema):
37 + class Meta:
38 + fields = (
39 + "id",
40 + "node",
41 + "disk_used",
42 + "disk_available",
43 + "disk_total",
44 + "disk_percent",
45 + "timestamp",
46 + )
47 +
48 +
49 +wazuh_indexer_allocation_schema = WazuhIndexerAllocationSchema()
50 +wazuh_indexer_allocations_schema = WazuhIndexerAllocationSchema(many=True)