async def note_create(*,
body: str = Form(...),
db: database.Session = Depends(get_db)):
note = models.Note(body=body)
db.add(note)
db.commit()
return RedirectResponse(f'/note/{note.id}')
def create_note(user_id: int, note: schemas.NoteCreate,
db: Session) -> schemas.Note:
note_dict = note.dict()
note_dict["user_id"] = user_id
db_note = models.Note(**note_dict)
db.add(db_note)
db.commit()
db.refresh(db_note)
return db_note
def post(self):
'''
method to add a note
'''
args = self.reqparse.parse_args()
print args
note = models.Note(args["content"], args["width"], args["color"])
db.session.add(note)
db.session.commit()
return {"note": marshal(note, NOTE_FIELDS)}, 201
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('title', required=True)
parser.add_argument('text')
args = parser.parse_args()
user = models.User.query.filter_by(username=get_jwt_identity()).first()
new_note = models.Note(author=user.id)
new_note.text = args.get('text', '')
new_note.title = args.get('title', '')
db.session.add(new_note)
db.session.commit()
return new_note
def post(model_id, model_name):
note = request.json.get('note', '')
new_note = models.Note(
note=note,
model_name=model_name,
model_id=model_id,
created_by=g.request_user,
updated_by=g.request_user
)
db.session.add(new_note)
db.session.commit()
return jsonify(new_note.__getstate__()), 200
def full_case(test_db, basic_test_survey, basic_case_definition, admin_user):
"""Fully filled out case. Object contains case information including all child objects. Records included
* case
* case definition
* survey
* survey responses
* uploaded files
* notes
"""
case = models.Case(name='Full Case',
case_definition_id=basic_case_definition.id,
created_by=admin_user,
updated_by=admin_user)
case.responses.append(
models.SurveyResponse(survey_id=basic_test_survey.id,
structure={},
created_by=admin_user,
updated_by=admin_user))
test_db.session.add(case)
test_db.session.commit()
note = models.Note(model_id=case.id,
model_name='Case',
note='Test Case Note',
created_by=admin_user,
updated_by=admin_user)
# this does actually need to point to a real file. we just need a db record
file = models.UploadedFile(model_id=case.id,
model_name='Case',
created_by=admin_user)
test_db.session.add(note)
test_db.session.add(file)
test_db.session.commit()
return case
def post(self, activity_definition=None):
activity_name = self.json_args.get('name', None)
if not activity_name:
msg = flask_babel.gettext("A name is required for a activity.")
return jsonify({"message": msg}), 400
if len(activity_name) < 8:
msg = flask_babel.gettext(
"Activity names must be at least 8 characters long.")
return jsonify({"message": msg}), 400
# if len(activity_name) > 50:
# msg = flask_babel.gettext("Activity names cannot be longer than 50 characters.")
# return jsonify({"message": msg}), 400
case_id = self.json_args.get('case_id', None)
name_check = db.session.query(models.Activity).filter(
models.Activity.case_id == case_id,
models.Activity.name == activity_name).all()
if len(name_check):
msg = flask_babel.gettext("Activity names must be unique.")
return jsonify({"message": msg}), 400
case_description = self.json_args.get('description', None)
is_complete = self.json_args.get('is_complete', False)
if is_complete == True:
completed_by = g.request_user
completed_at = datetime.utcnow()
else:
is_complete = False
completed_by = None
completed_at = None
activity_definition_id = activity_definition.id if activity_definition is not None else None
activity = models.Activity(
activity_definition_id=activity_definition_id,
case_id=case_id,
name=activity_name,
description=case_description,
is_complete=is_complete,
completed_at=completed_at,
completed_by=completed_by,
created_by=g.request_user,
updated_by=g.request_user,
)
created_location_data = helpers.parse_gps(self.json_args)
if created_location_data.longitude is not None and created_location_data.latitude is not None:
activity.created_location_coordinates = \
f"POINT({created_location_data.longitude} {created_location_data.latitude})"
activity.created_location_position_accuracy = created_location_data.position_accuracy
activity.created_location_altitude = created_location_data.altitude
activity.created_location_altitude_accuracy = created_location_data.altitude_accuracy
activity.created_location_heading = created_location_data.heading
activity.created_location_speed = created_location_data.speed
activity.created_location_dt = created_location_data.location_dt
if 'custom_fields' in self.json_args:
if isinstance(self.json_args.get('custom_fields'), list):
for submitted_custom_field in self.json_args.get(
'custom_fields'):
if not submitted_custom_field.get('id'):
msg = flask_babel.gettext(
"IDs cannot not be empty for custom fields")
return jsonify({"message": msg}), 400
current_app.logger.info(
f"processing cf : {submitted_custom_field['id']}")
if activity_definition.get_custom_field(
submitted_custom_field[
'activity_definition_custom_field_id']):
current_app.logger.info(
'found activity defns custom field')
act_defn_cf = activity_definition.get_custom_field(
submitted_custom_field[
'activity_definition_custom_field_id'])
if self._validate_custom_field(submitted_custom_field,
act_defn_cf):
if models.User.query.get(
submitted_custom_field['created_by_id']):
created_by = models.User.query.get(
submitted_custom_field['created_by_id'])
else:
created_by = g.request_user
if models.User.query.get(
submitted_custom_field['updated_by_id']):
updated_by = models.User.query.get(
submitted_custom_field['updated_by_id'])
else:
updated_by = g.request_user
created_at = submitted_custom_field.get(
'created_at',
datetime.utcnow().isoformat())
updated_at = submitted_custom_field.get(
'updated_at',
datetime.utcnow().isoformat())
try:
activity.add_custom_field(
custom_field=act_defn_cf,
created_by=created_by,
custom_field_id=submitted_custom_field[
'id'],
updated_by=updated_by,
created_at=created_at,
updated_at=updated_at)
activity.update_custom_field_value(
custom_field=submitted_custom_field,
updated_by=updated_by,
updated_at=updated_at)
except KeyError:
msg = flask_babel.gettext(
"Submitted custom field IDs must be unique"
)
return jsonify({"message": msg}), 400
else:
msg = flask_babel.gettext("Invalid custom field")
return jsonify({"message": msg}), 400
else:
msg = flask_babel.gettext(
"Unknown activity definition custom field ID")
return jsonify({"message": msg}), 400
self._ensure_all_activity_definition_custom_fields_were_submitted(
activity, activity_definition)
else:
msg = flask_babel.gettext(
"custom_fields property must be a list")
return jsonify({"message": msg}), 400
else:
if activity_definition and activity_definition.custom_fields:
for custom_field in activity_definition.custom_fields:
activity.add_custom_field(custom_field, g.request_user,
g.request_user)
self.session.add(activity)
self.session.commit()
notes = self.json_args.get('notes', [])
for note in notes:
if note:
new_note = models.Note(note=note,
model_name='Activity',
model_id=activity.id,
created_by=g.request_user,
updated_by=g.request_user)
self.session.add(new_note)
self.session.commit()
# current_app.reporting_service.add_case_row(activity)
return jsonify(activity.__getstate__()), 200