# if current_user and current_user.is_authenticated: solar_data = solar_service.get_detail(solarid) if solar_data: data = solar_data.to_dict() data['panels'] = solar_data.get_panels_data() data["photos"] = solar_data.get_photos_data() return data abort(404, message="Solar id={0} not found".format(solarid)) # abort(401, message="Requires user to login") def put(self, solarid): data = request.json log.debug("Edit Solar request {0}: {1}".format(solarid, data)) # TODO check authenticated user # if current_user and current_user.is_authenticated: try: solar_data = solar_service.update_from_dict(solarid, data) result = dict(status=200, message="OK", solar=solar_data) return marshal(result, solar_create_fields) except SolarNotFoundError as err: abort(404, message=err.message) # abort(401, message="Requires user to login") rest_api.add_resource(SolarsResource, '/api/solars') rest_api.add_resource(SolarDetailResource, '/api/solars/<int:solarid>')
try: audit = sign_audit(audit_id, uploaded_file) result = dict(status=200, message="OK", audit=audit) return marshal(result, audit_create_fields) except AuditNotFoundError as err: abort(404, message=err.message) def put(self, audit_id): """ PUT /api/audits/<audit_id>/signature """ log.debug( "PUT Upload Audit Signature Photo request id={0} files={1} form data={2}" .format(audit_id, request.files, request.form)) uploaded_file = request.files['file'] signature_id = request.form.get('signature[id]') try: signature = update_audit_signature(audit_id, signature_id, uploaded_file) result = dict(status=200, message="OK", signature=signature) return marshal(result, signature_create_fields) except (AuditNotFoundError, AuditSignatureNotFoundError) as err: abort(404, message=err.message) rest_api.add_resource(AuditTemplatesResource, '/api/audit_templates') rest_api.add_resource(AuditTemplateDetailsResource, '/api/audit_templates/<int:audit_template_id>') rest_api.add_resource(AuditsResource, '/api/audits') rest_api.add_resource(AuditDetailsResource, '/api/audits/<int:audit_id>') rest_api.add_resource(AuditSignatureResource, '/api/audits/<int:audit_id>/signature')
# """ # # @marshal_with(section_complete_fields) # def get(self, c_id): # log.debug('GET Crematorium request id={0}: {1}'.format(c_id, request.json)) # section = section_service.get_section(c_id) # if section: # data = section.to_dict() # data['blocks'] = section.get_blocks() # return data # abort(404, message="Crematorium id={0} not found".format(c_id)) # # def put(self, c_id): # """ PUT /api/crematorium/<c_id> """ # form_data = request.json # log.debug('Update Crematorium request id {0}: {1}'.format(c_id, form_data)) # form = AddSectionForm.from_json(form_data) # if form.validate(): # try: # section = section_service.update_from_dict(c_id, form_data) # result = dict(status=200, message='OK', section=section) # return marshal(result, section_create_fields) # except CrematoriumNotFoundError as err: # abort(404, message=err.message) # else: # abort(400, message="Invalid Parameters", errors=form.errors) rest_api.add_resource(CrematoriumResource, '/api/crematorium') # rest_api.add_resource(CrematoriumDetailResource, '/api/crematorium/<int:c_id>')
def init_all(): rest_api.add_resource(SubjectsListResource, api_prefix + '/subjects/') rest_api.add_resource(StudentResource, api_prefix + '/student/<string:vk_id>') rest_api.add_resource(NotificationsListResource, api_prefix + '/notifications/<int:last_id>') rest_api.add_resource(StudentsToGroupsResource, api_prefix + '/students_to_groups/') rest_api.add_resource(StudentDeclinesResource, api_prefix + '/student_declines/<string:vk_id>')
API_UNITS = { 'm':'SI meters', 's':'SI seconds' } class SiteList(restful.Resource): def get(self): api_response = ApiResponse() sites = Site.query.all() for site in sites: api_response += site # print api_response.json() return api_response.json() rest_api.add_resource(SiteList, '/sites') class SiteResource(restful.Resource): def get(self, site_id): response = ApiResponse(request) site = Site.query.filter_by(id = site_id).first() if site: response += site else: response += exc.MissingResourceException(type(self), site_id) return response.json() def delete(self, site_id): response = ApiResponse(request) site = Site.query.filter_by(id = site_id).first() if site:
from files import api as files_api from events import api as events_api from reviews import api as reviews_api from invitedGuest import api as invitedGuest_api from references import api as reference_api from registration import api as registration_api from registrationResponse import api as registration_response from guestRegistrations import api as guest_registration from invitationletter import api as invitation_letter_api from attendance import api as attendance_api from organisation import api as organisation_api from integration_tests import api as integration_tests_api from outcome import api as outcome_api from tags import api as tag_api rest_api.add_resource(users_api.UserAPI, '/api/v1/user') rest_api.add_resource(users_api.UserCommentAPI, '/api/v1/user-comment') rest_api.add_resource(users_api.AuthenticationAPI, '/api/v1/authenticate') rest_api.add_resource(users_api.AuthenticationRefreshAPI, '/api/v1/authenticationrefresh') rest_api.add_resource(users_api.PasswordResetRequestAPI, '/api/v1/password-reset/request') rest_api.add_resource(users_api.PasswordResetConfirmAPI, '/api/v1/password-reset/confirm') rest_api.add_resource(users_api.AdminOnlyAPI, '/api/v1/admin') rest_api.add_resource(users_api.EmailerAPI, '/api/v1/admin/emailer') rest_api.add_resource(form_api.ApplicationFormAPI, '/api/v1/application-form') rest_api.add_resource(responses_api.ResponseAPI, '/api/v1/response') rest_api.add_resource(content_api.CountryContentAPI, '/api/v1/content/countries') rest_api.add_resource(files_api.FileUploadAPI, '/api/v1/file')
# form = DelegateActionForm.from_json(form_data['data']) # if form.validate(): response = respond_to_action(action_id, current_user.id, form_data) result = dict(status=200, message='OK', response=response) return marshal(result, action_response_create_fields) # else: # abort(400, message="Invalid Parameters", errors=form.errors) abort(401, message="Requires user to login") class MarkDoneActionResource(Resource): """ Resource for Marking action as done """ def put(self, action_id): """ POST /api/actions/<action_id>/done """ if current_user and current_user.is_authenticated: log.debug('Marking action as done request') action = mark_action_done(action_id, current_user.id) result = dict(status=200, message='OK', action=action) return marshal(result, action_create_fields) abort(401, message="Requires user to login") rest_api.add_resource(ActionsResource, '/api/actions') rest_api.add_resource(ActionDetailsResource, '/api/actions/<int:action_id>') rest_api.add_resource(ActionResponseResource, '/api/actions/<int:action_id>/responses') rest_api.add_resource(MarkDoneActionResource, '/api/actions/<int:action_id>/done')
log = logging.getLogger(__name__) class SchemasResource(Resource): """ Resource for getting all FormSchema json files """ @marshal_with(schema_fields) def get(self): if current_user and current_user.is_authenticated: return get_form_schemas() abort(401, message="Requires user to login") class SchemasDetailResource(Resource): """ Resource for FormSchema Detail json files """ def post(self, name): if current_user and current_user.is_authenticated: update_form_schema(name, request.json) return dict(status=200, message="OK") abort(401, message="Requires user to login") rest_api.add_resource(SchemasResource, '/api/form_schemas') rest_api.add_resource(SchemasDetailResource, '/api/form_schemas/<name>')
from app import rest_api from users import api as users_api rest_api.add_resource(users_api.UserAPI, '/api/v1/user') rest_api.add_resource(users_api.AuthenticationAPI, '/api/v1/authenticate') rest_api.add_resource(users_api.PasswordResetRequestAPI, '/api/v1/password-reset/request') rest_api.add_resource(users_api.PasswordResetConfirmAPI, '/api/v1/password-reset/confirm') rest_api.add_resource(users_api.VerifyEmailAPI, '/api/v1/verify-email'), rest_api.add_resource(users_api.ResendVerificationEmailAPI, '/api/v1/resend-verification-email'), rest_api.add_resource(users_api.UserProfileList, '/api/v1/userprofilelist')
class DocumentsResource(Resource): """ Resource for getting all Documents Resource """ def post(self): """ POST /api/documents """ log.debug("POST Upload Document request {0} {1}".format( request.files, request.form)) # uploaded_file = request.files['file'] # if uploaded_file: # caption = request.form['caption'] if request.form['caption'] is not None else '' # document = upload_document(uploaded_file, caption) # result = dict(status=200, message="OK", document=document) # return marshal(result, document_create_fields) # else: # abort(400, message="Invalid parameters") rest_api.add_resource(DepartmentsResource, '/api/departments') rest_api.add_resource(EmployeesResource, '/api/employees') rest_api.add_resource(AssetsResource, '/api/assets') rest_api.add_resource(IncidentTypesResource, '/api/incident_types') rest_api.add_resource(RiskTypesResource, '/api/risk_types') rest_api.add_resource(IncidentsResource, '/api/incidents') rest_api.add_resource(IncidentDetailsResource, '/api/incidents/<int:incident_id>') rest_api.add_resource(IncidentPhotosResource, '/api/incidents/<int:incident_id>/photos') rest_api.add_resource(PhotoDetailResource, '/api/photos/<int:photo_id>') rest_api.add_resource(DocumentsResource, '/api/documents')
""" GET /api/clients """ # TODO check authenticated user # TODO: Handle logins for 401s clients = client_service.get_clients() log.debug("Clients Resource Data: {0}".format(clients)) return clients # def post(self): # TODO Get rid of these one, throw all on /api/lots/lot_id # """ POST /api/clients """ # form_data = request.json # log.debug('Add Client for lot request: {0}'.format(form_data)) # TODO check authenticated user # form = AddClientForm.from_json(form_data) # try: # if form.validate(): # client = client_service.create_from_dict(form_data) # # # Update Lot here # lot = lot_service.sold_lot(form_data['lot_id'], client.id) # # result = dict(status=200, message='OK', client=client, lot=lot) # # return marshal(result, lot_client_create_fields) # else: # abort(400, message="Invalid Parameters", errors=form.errors) # except ValueError as err: # abort(403, message=err.message) rest_api.add_resource(ClientsResource, '/api/clients')
class SettingsResource(Resource): """ Resource for Block """ def post(self): """ POST /api/settings """ form_data = request.json log.debug('Update Settings request: {0}'.format(form_data)) settings = setting_service.update_settings(form_data) result = dict(status=200, message='OK', settings=settings) log.debug("Result: {0}".format(result)) return marshal(result, success_settings_fields) class LastLotPriceResource(Resource): """ Resource for LastLotPrice """ @marshal_with(settings_fields) def get(self): """ GET /api/settings/last_lot_price """ last_lot = setting_service.get_current_settings() return last_lot rest_api.add_resource(SettingsResource, '/api/settings') rest_api.add_resource(LastLotPriceResource, '/api/settings/last_lot_price')
from app import rest_api from app.api.pimpy.minutes import MinuteResource, GroupMinuteResource from app.api.pimpy.tasks import TaskListResource, TaskResource, \ GroupTaskListResource # Pimpy Tasks rest_api.add_resource(TaskListResource, '/api/tasks/', endpoint="api.task") rest_api.add_resource(TaskResource, '/api/tasks/<string:task_id>', endpoint="api.tasks") rest_api.add_resource(GroupTaskListResource, '/api/groups/<int:group_id>/tasks', endpoint="api.groups.tasks") # Pimpy Minutes rest_api.add_resource(MinuteResource, "/api/minutes/<int:minute_id>", endpoint="api.minute") rest_api.add_resource(GroupMinuteResource, "/api/groups/<int:group_id>/minutes", endpoint="api.groups.minutes")
class SectionBlocksResource(Resource): """ Resource for Section Blocks """ @marshal_with(block_basic_fields) def get(self, section_id): """ GET /api/sections/section_id/blocks """ log.debug("Get All Blocks for Section : {0}".format(section_id)) try: return block_service.get_blocks_for_section(section_id) except SectionNotFoundError as err: abort(403, message=err.message) def post(self, section_id): """ POST /api/sections/<section_id>/blocks """ form_data = request.json log.debug('Add Block for Section id={0} request: {1}'.format(section_id, form_data)) # TODO check authenticated user form = AddBlockForm.from_json(form_data) if form.validate(): block = block_service.create_from_dict(section_id, form_data) result = dict(status=200, message='OK', block=block) return marshal(result, block_create_fields) else: abort(400, message="Invalid Parameters", errors=form.errors) rest_api.add_resource(BlocksResource, '/api/blocks') rest_api.add_resource(SectionBlocksResource, '/api/sections/<int:section_id>/blocks')
@marshal_with(hazard_complete_fields) def get(self, hazard_id): """ GET /api/hazards/<hazard_id> """ return get_hazard_details(hazard_id) def delete(self, hazard_id): """ DELETE /api/hazards/<hazard_id> """ try: delete_hazard(hazard_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except HazardNotFoundError as err: abort(404, message=err.message) rest_api.add_resource(RiskAssessmentResource, '/api/risk_assessments') rest_api.add_resource(RiskAssessmentDetailsResource, '/api/risk_assessments/<int:risk_assessment_id>') rest_api.add_resource(RiskAssessmentRisksResource, '/api/risk_assessments/<int:risk_assessment_id>/risks') rest_api.add_resource(AssessmentRiskResource, '/api/assessment_risk/<int:assessment_risk_id>') rest_api.add_resource( RiskAssessmentActionsResource, '/api/risk_assessments/<int:risk_assessment_id>/actions') rest_api.add_resource( RiskAssessmentActionResource, '/api/risk_assessment_action/<int:risk_assessment_action_id>') rest_api.add_resource(HazardResource, '/api/hazards') rest_api.add_resource(HazardDetailsResource, '/api/hazards/<int:hazard_id>')
log = logging.getLogger(__name__) class DeceasedResource(Resource): """ Resource for Deceased """ """ PUT /api/deceased/deceased_id """ def put(self, deceased_id): form_data = request.json log.debug("Update Deceased Request id={0} : {1}".format(deceased_id, form_data)) try: deceased = deceased_service.update_deceased(deceased_id, form_data) result = dict(status=200, message='OK', deceased=deceased) return marshal(result, deceased_create_fields) except DeceasedNotFoundError as err: abort(403, message=err.message) def delete(self, deceased_id): """ DELETE /api/deceased/deceased_id """ try: deceased_service.delete_deceased(deceased_id) result = dict(status=200, message='OK') return marshal(result, ok_response) except DeceasedNotFoundError as err: abort(403, message=err.message) rest_api.add_resource(DeceasedResource, '/api/deceased/<int:deceased_id>')
columbary = sold_columbary(c_id, form_data) result = dict(status=200, message='OK', columbary=columbary) return marshal(result, columbary_create_fields) except ColumbaryNotFoundError as err: abort(404, message=err.message) class ColumbaryDeceasedResource(Resource): """ Resource for Deceased Columbary """ def post(self, c_id): """ POST /api/columbary/<c_id>/deceased """ form_data = request.json log.debug('Add Deceased for Columbary id={0} request: {1}'.format(c_id, form_data)) # TODO check authenticated user form = AddDeceasedForm.from_json(form_data) if form.validate(): data = add_occupant(c_id, form_data) result = dict(status=200, message='OK', deceased=data) return marshal(result, deceased_create_fields) else: abort(400, message="Invalid Parameters", errors=form.errors) rest_api.add_resource(ColumbaryResource, '/api/columbary') rest_api.add_resource(ColumbaryAllResource, '/api/columbary/all') rest_api.add_resource(ColumbaryDetailResource, '/api/columbary/<int:c_id>') rest_api.add_resource(MarkSoldColumbaryResource, '/api/columbary/<int:c_id>/mark_sold') rest_api.add_resource(ColumbaryDeceasedResource, '/api/columbary/<int:c_id>/deceased')
from app import rest_api from users import api as users_api rest_api.add_resource(users_api.UserAPI, '/api/v1/user') rest_api.add_resource(users_api.AuthenticationAPI, '/api/v1/authenticate') rest_api.add_resource(users_api.PasswordResetRequestAPI, '/api/v1/password-reset/request') rest_api.add_resource(users_api.PasswordResetConfirmAPI, '/api/v1/password-reset/confirm') rest_api.add_resource(users_api.AdminOnlyAPI, '/api/v1/admin')
return jsonify(ApiObjects(site.json())) else: return jsonify(ApiObjects()) @http_auth_required def post(self): parser = reqparse.RequestParser(bundle_errors = True) parser.add_argument('name', type=str, location='form', required=True, help='<str> name required') args = parser.parse_args() site = Site.create(name = args['name']) if site: return jsonify(ApiObjects(site.json())) else: return jsonify(ApiObjects()) rest_api.add_resource(SiteResource, '/site/<int:site_id>', '/site') class SiteListResource(restful.Resource): def get(self): sites = Site.query.all() if sites: return jsonify(ApiObjects([site.json() for site in sites])) else: return jsonify(ApiObjects()) rest_api.add_resource(SiteListResource, '/sites')
def put(self, site_design_id): """ PUT /site_designs/<site_design_id> """ if current_user and current_user.is_authenticated: try: form_data = request.json log.debug("Update Site Design Request: {0}".format(form_data)) site_design = update_site_design(site_design_id, form_data) result = dict(status=200, message='OK', site_design=site_design) return marshal(result, site_design_create_fields) except SiteDesignNotFoundError as err: abort(404, message=err.message) abort(401, message="Requires user to login") class SiteDesignComponentUnitsResource(Resource): """ Resource for Site Design Component Units """ @marshal_with(site_design_component_unit_fields) def get(self, component_unit_id): """ GET /component_units/<component_unit_id>/site_designs """ log.debug("Get Site Design Component Units Request component_unit_id={0}".format(component_unit_id)) return get_site_design_component_units(component_unit_id) rest_api.add_resource(ComponentUnitsResource, '/api/component_units') rest_api.add_resource(SiteDesignsResource, '/api/site_designs') rest_api.add_resource(SiteDesignDetailsResource, '/api/site_designs/<int:site_design_id>') rest_api.add_resource(SiteDesignComponentUnitsResource, '/api/component_units/<int:component_unit_id>/site_designs')
import ujson API_UNITS = {'m': 'SI meters', 's': 'SI seconds'} class SiteList(restful.Resource): def get(self): api_response = ApiResponse() sites = Site.query.all() for site in sites: api_response += site # print api_response.json() return api_response.json() rest_api.add_resource(SiteList, '/sites') class SiteResource(restful.Resource): def get(self, site_id): response = ApiResponse(request) site = Site.query.filter_by(id=site_id).first() if site: response += site else: response += exc.MissingResourceException(type(self), site_id) return response.json() def delete(self, site_id): response = ApiResponse(request) site = Site.query.filter_by(id=site_id).first()
delete_work_step(work_permit_id, step_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except WorkPermitNotFoundError as err: abort(404, message=err.message) class WorkPermitHazardsResource(Resource): """ Resource for getting Work Permit hazards """ def delete(self, work_permit_id): haz_id = request.args.get('id') log.debug('Delete Work Hazard id={0} , work hazard id={1}'.format( work_permit_id, haz_id)) try: delete_work_hazard(work_permit_id, haz_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except WorkPermitNotFoundError as err: abort(404, message=err.message) rest_api.add_resource(WorkPermitsResource, '/api/work_permits') rest_api.add_resource(WorkPermitDetailsResource, '/api/work_permits/<int:work_permit_id>') rest_api.add_resource(WorkPermitStepsResource, '/api/work_permits/<int:work_permit_id>/steps') rest_api.add_resource(WorkPermitHazardsResource, '/api/work_permits/<int:work_permit_id>/hazards')
from app import app, rest_api from flask.ext.restful import Resource, abort, marshal_with, marshal from flask import request from .fields import building_fields, building_create_fields from .services import get_buildings, create_building import logging log = logging.getLogger(__name__) class BuildingsResource(Resource): """ Resource for Buildings """ @marshal_with(building_fields) def get(self): return get_buildings() def post(self): form_data = request.json log.debug('Add Building request: {0}'.format(form_data)) obj = create_building(form_data) result = dict(status=200, message='OK', building=obj) return marshal(result, building_create_fields) rest_api.add_resource(BuildingsResource, '/api/buildings')
class DocumentsResource(Resource): """ Resource for getting all Documents Resource """ def post(self): """ POST /api/documents """ log.debug("POST Upload Document request {0} {1}".format(request.files, request.form)) # uploaded_file = request.files['file'] # if uploaded_file: # caption = request.form['caption'] if request.form['caption'] is not None else '' # document = upload_document(uploaded_file, caption) # result = dict(status=200, message="OK", document=document) # return marshal(result, document_create_fields) # else: # abort(400, message="Invalid parameters") rest_api.add_resource(DepartmentsResource, '/api/departments') rest_api.add_resource(EmployeesResource, '/api/employees') rest_api.add_resource(AssetsResource, '/api/assets') rest_api.add_resource(IncidentTypesResource, '/api/incident_types') rest_api.add_resource(RiskTypesResource, '/api/risk_types') rest_api.add_resource(IncidentsResource, '/api/incidents') rest_api.add_resource(IncidentDetailsResource, '/api/incidents/<int:incident_id>') rest_api.add_resource(IncidentPhotosResource, '/api/incidents/<int:incident_id>/photos') rest_api.add_resource(PhotoDetailResource, '/api/photos/<int:photo_id>') rest_api.add_resource(DocumentsResource, '/api/documents')
section = section_service.get_section(section_id) if section: data = section.to_dict() data['blocks'] = section.get_blocks() return data abort(404, message="Section id={0} not found".format(section_id)) # abort(401, message="Requires user to login") def put(self, section_id): """ PUT /api/sections/<section_id> """ form_data = request.json log.debug('Update Section request id {0}: {1}'.format( section_id, form_data)) # TODO check authenticated user form = AddSectionForm.from_json(form_data) if form.validate(): try: section = section_service.update_from_dict( section_id, form_data) result = dict(status=200, message='OK', section=section) return marshal(result, section_create_fields) except SectionNotFoundError as err: abort(404, message=err.message) else: abort(400, message="Invalid Parameters", errors=form.errors) rest_api.add_resource(SectionsResource, '/api/sections') rest_api.add_resource(SectionsBasicResource, '/api/sections/basic') rest_api.add_resource(SectionDetailResource, '/api/sections/<int:section_id>')
@marshal_with(client_fields) def get(self): """ GET /api/clients """ # TODO check authenticated user # TODO: Handle logins for 401s clients = client_service.get_clients() log.debug("Clients Resource Data: {0}".format(clients)) return clients class LotClientResource(Resource): def put(self, lot_id): """ PUT /api/lots/<lot_id>/client """ form_data = request.json log.debug('Update Lot Client request id={0} {1}'.format(lot_id, form_data)) try: # client = client_service.create_from_dict(form_data) # Update Lot here lot = lot_service.update_lot_client(lot_id, form_data) result = dict(status=200, message='OK', lot=lot) return marshal(result, lot_create_fields) except LotNotFoundError as err: abort(403, message=err.message) rest_api.add_resource(ClientsResource, '/api/clients') rest_api.add_resource(LotClientResource, '/api/lots/<int:lot_id>/client')
""" def delete(self, solar_id, panel_id): data = request.json log.debug("Delete Solar Panel Detail request Solar={0} Panel={1} Data={2}".format(solar_id, panel_id, data)) # TODO check authenticated user # if current_user and current_user.is_authenticated: try: solar_panel_service.delete_panel(solar_id, panel_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except ValueError as err: abort(404, message=err.message) # abort(401, message="Requires user to login") def put(self, solar_id, panel_id): data = request.json log.debug("Update Solar Panel Detail request Solar={0} Panel={1} Data={2}".format(solar_id, panel_id, data)) # TODO check authenticated user # if current_user and current_user.is_authenticated: try: panel_data = solar_panel_service.update_panel_area(solar_id, panel_id, data) result = dict(status=200, message="OK", panel=panel_data) return marshal(result, solar_panel_create_fields) except ValueError as err: abort(404, message=err.message) # abort(401, message="Requires user to login") rest_api.add_resource(SolarPanelResource, '/api/solars/<int:solar_id>/panels') rest_api.add_resource(SolarPanelDetailResource, '/api/solars/<int:solar_id>/panels/<int:panel_id>')
""" def post(self, project_id): """ POST /api/projects/<project_id>/files """ log.debug('Update Project File {0} request: {1}'.format(project_id, request.form)) if current_user and current_user.is_authenticated: uploaded_file = request.files['file'] # TODO: Delete previous associated file before saving new one for good housekeeping if self.has_valid_form() and uploaded_file and self.allowed_file(uploaded_file.filename): filename = self.copy_file(uploaded_file) data = dict(id=project_id, sections=self.get_files_form_data(filename)) try: file = save_files_from_dict(project_id, data) file.date_created = file.date_created.isoformat() file.date_modified = file.date_modified.isoformat() file.coordinates = GISHelper.point_to_latlng_dict(file.coordinates) filedict = file.to_dict() return dict(status=200, message="OK", file=filedict) except ProjectNotFoundError as err: abort(404, message=err.message) else: abort(400, message="Invalid parameters") abort(401, message="Requires user to login") rest_api.add_resource(ProjectsResource, '/api/projects') rest_api.add_resource(ProjectDetailsResource, '/api/projects/<int:project_id>') rest_api.add_resource(ProjectSectionsResource, '/api/projects/<int:project_id>/sections') rest_api.add_resource(ProjectFilesResource, '/api/projects/<int:project_id>/files')
allow_null=False)) class SettingsResource(Resource): """ Resource for Block """ def post(self): """ POST /api/settings """ form_data = request.json log.debug('Update Settings request: {0}'.format(form_data)) settings = setting_service.update_settings(form_data) result = dict(status=200, message='OK', settings=settings) log.debug("Result: {0}".format(result)) return marshal(result, success_settings_fields) class LastLotPriceResource(Resource): """ Resource for LastLotPrice """ @marshal_with(settings_fields) def get(self): """ GET /api/settings/last_lot_price """ last_lot = setting_service.get_current_settings() return last_lot rest_api.add_resource(SettingsResource, '/api/settings') rest_api.add_resource(LastLotPriceResource, '/api/settings/last_lot_price')
step_id = request.args.get('id') log.debug('Delete Work Step id={0} , step id={1}'.format(work_permit_id, step_id)) try: delete_work_step(work_permit_id, step_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except WorkPermitNotFoundError as err: abort(404, message=err.message) class WorkPermitHazardsResource(Resource): """ Resource for getting Work Permit hazards """ def delete(self, work_permit_id): haz_id = request.args.get('id') log.debug('Delete Work Hazard id={0} , work hazard id={1}'.format(work_permit_id, haz_id)) try: delete_work_hazard(work_permit_id, haz_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except WorkPermitNotFoundError as err: abort(404, message=err.message) rest_api.add_resource(WorkPermitsResource, '/api/work_permits') rest_api.add_resource(WorkPermitDetailsResource, '/api/work_permits/<int:work_permit_id>') rest_api.add_resource(WorkPermitStepsResource, '/api/work_permits/<int:work_permit_id>/steps') rest_api.add_resource(WorkPermitHazardsResource, '/api/work_permits/<int:work_permit_id>/hazards')
from app import rest_api from boards import api as board_api rest_api.add_resource(board_api.BoardAPI, '/api/v1/board') rest_api.add_resource(board_api.BoardsByUserAPI, '/api/v1/boardsbyuser') rest_api.add_resource(board_api.Boards, '/api/v1/boards')
from flask.ext.restful import Resource, abort, marshal_with, marshal from flask import request from app import app, rest_api from .services import * from .fields import * from flask_login import current_user import logging log = logging.getLogger(__name__) class UsersResource(Resource): """ Resource for Users """ @marshal_with(user_fields) def get(self): """ GET /users """ # TODO check authenticated user # TODO: Handle logins for 401s and get_solars_for_user return get_users() rest_api.add_resource(UsersResource, '/api/users')
def delete(self, order_substance_id): material_id = request.args.get('material_id', 0) log.debug( 'Delete Dangerous Substance Order Material Request id={0} : {1}'. format(order_substance_id, material_id)) try: delete_dangerous_substance_order_material(material_id, order_substance_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except (DangerousSubstanceOrderNotFoundError, DangerousSubstanceOrderMaterialNotFoundError) as err: abort(404, message=err.message) rest_api.add_resource(AgentsResource, '/api/agents') rest_api.add_resource(AgentDetailResource, '/api/agents/<int:agent_id>') rest_api.add_resource(MaterialTypesResource, '/api/material_types') rest_api.add_resource(HazardMaterialsResource, '/api/hazard_materials') rest_api.add_resource(HazardMaterialDetailResource, '/api/hazard_materials/<int:material_id>') rest_api.add_resource(ContractorsResource, '/api/contractors') rest_api.add_resource(ContractorDetailsResource, '/api/contractors/<int:contractor_id>') rest_api.add_resource(WasteDisposalsResource, '/api/waste_disposals') rest_api.add_resource(WasteDisposalDetailsResource, '/api/waste_disposals/<int:waste_disposal_id>') rest_api.add_resource( WasteDisposalDocumentsResource, '/api/waste_disposals/<int:waste_disposal_id>/documents') rest_api.add_resource(DangerousSubstanceOrdersResource,
# if current_user and current_user.is_authenticated: new_caption = data['caption'] form = UpdatePhotoCaptionForm.from_json(data) if form.validate(): try: solar_file_obj = solar_file_service.update_photo_caption(solar_id, photo_id, new_caption) result = dict(status=200, message="OK", solar_file=solar_file_obj) return marshal(result, solar_file_create_fields) except ValueError as err: abort(404, message=err.message) else: abort(400, message="Invalid parameters") # abort(401, message="Requires user to login") def delete(self, solar_id, photo_id): data = request.json log.debug("Delete Solar Panel Detail request Solar={0} Panel={1} Data={2}".format(solar_id, photo_id, data)) # TODO check authenticated user # if current_user and current_user.is_authenticated: try: filename = solar_file_service.delete_photo(solar_id, photo_id) # self.delete_file(filename) result = dict(status=200, message="OK") return marshal(result, success_fields) except ValueError as err: abort(404, message=err.message) # abort(401, message="Requires user to login") rest_api.add_resource(SolarPhotosResource, '/api/solars/<int:solar_id>/photos') rest_api.add_resource(SolarPhotosDetailResource, '/api/solars/<int:solar_id>/photos/<int:photo_id>')
log.debug('Add Action Response request: {0}'.format(form_data)) # Validation here # form = DelegateActionForm.from_json(form_data['data']) # if form.validate(): response = respond_to_action(action_id, current_user.id, form_data) result = dict(status=200, message='OK', response=response) return marshal(result, action_response_create_fields) # else: # abort(400, message="Invalid Parameters", errors=form.errors) abort(401, message="Requires user to login") class MarkDoneActionResource(Resource): """ Resource for Marking action as done """ def put(self, action_id): """ POST /api/actions/<action_id>/done """ if current_user and current_user.is_authenticated: log.debug('Marking action as done request') action = mark_action_done(action_id, current_user.id) result = dict(status=200, message='OK', action=action) return marshal(result, action_create_fields) abort(401, message="Requires user to login") rest_api.add_resource(ActionsResource, '/api/actions') rest_api.add_resource(ActionDetailsResource, '/api/actions/<int:action_id>') rest_api.add_resource(ActionResponseResource, '/api/actions/<int:action_id>/responses') rest_api.add_resource(MarkDoneActionResource, '/api/actions/<int:action_id>/done')
""" @marshal_with(waypoint_type_fields) def get(self): return get_waypoint_types() class WaypointsResource(Resource): """ Resource for Waypoints """ @marshal_with(waypoint_complete_fields) def get(self, buildingid, floorplanid): return get_waypoints(buildingid, floorplanid) def post(self, buildingid, floorplanid): form_data = request.json log.debug( 'Add waypoint request buildingid={0} floorplanid={1}: {2}'.format( buildingid, floorplanid, form_data)) obj = create_waypoint(buildingid, floorplanid, form_data) result = dict(status=200, message='OK', waypoint=obj) return marshal(result, waypoint_create_fields) rest_api.add_resource(WaypointTypesResource, '/api/waypoint_types') rest_api.add_resource( WaypointsResource, '/api/buildings/<int:buildingid>/floorplans/<int:floorplanid>/waypoints')
from flask.ext.restful import Resource, abort, marshal_with, marshal from app import app, rest_api from .services import * from .fields import * import logging log = logging.getLogger(__name__) class UsersResource(Resource): """ Resource for Users """ @marshal_with(user_fields) def get(self): """ GET /users """ return get_users() rest_api.add_resource(UsersResource, '/api/users')
""" GET /api/offices """ print "asset type showroom: {0}".format(AssetTypes.SHOWROOM) return get_assets(AssetTypes.MALL_EXHIBITS) class OfficesResource(Resource): """ Resource for Offices Resource """ @marshal_with(asset_fields) def get(self): """ GET /api/offices """ return get_assets(AssetTypes.OFFICE) rest_api.add_resource(ProjectTypesResource, '/api/project_types') rest_api.add_resource(ProjectsResource, '/api/projects') rest_api.add_resource(ProjectDetailsResource, '/api/projects/<int:project_id>') rest_api.add_resource(ProjectCondoFloorsResource, '/api/projects/<int:project_id>/floors') rest_api.add_resource(CondoUnitsResource, '/api/condo_units') rest_api.add_resource(ProjectCondoUnitsResource, '/api/projects/<int:project_id>/floors/<int:floor_id>/units') rest_api.add_resource(ProjectLotsResource, '/api/projects/<int:project_id>/lots') rest_api.add_resource(LotsResource, '/api/lots') rest_api.add_resource(LotDetailsResource, '/api/lots/<int:lot_id>') rest_api.add_resource(ProjectPhotosResource, '/api/projects/<int:project_id>/photos') rest_api.add_resource(CustomersResource, '/api/customers') rest_api.add_resource(ProspectsResource, '/api/prospects') rest_api.add_resource(ShowroomsResource, '/api/showrooms') rest_api.add_resource(MallExhibitsResource, '/api/mall_exhibits') rest_api.add_resource(OfficesResource, '/api/offices')
abort(401, message="Requires user to login") class HazardDetailsResource(Resource): """ Resource for getting Hazard Details Resource """ @marshal_with(hazard_complete_fields) def get(self, hazard_id): """ GET /api/hazards/<hazard_id> """ return get_hazard_details(hazard_id) def delete(self, hazard_id): """ DELETE /api/hazards/<hazard_id> """ try: delete_hazard(hazard_id) result = dict(status=200, message="OK") return marshal(result, success_fields) except HazardNotFoundError as err: abort(404, message=err.message) rest_api.add_resource(RiskAssessmentResource, '/api/risk_assessments') rest_api.add_resource(RiskAssessmentDetailsResource, '/api/risk_assessments/<int:risk_assessment_id>') rest_api.add_resource(RiskAssessmentRisksResource, '/api/risk_assessments/<int:risk_assessment_id>/risks') rest_api.add_resource(AssessmentRiskResource, '/api/assessment_risk/<int:assessment_risk_id>') rest_api.add_resource(RiskAssessmentActionsResource, '/api/risk_assessments/<int:risk_assessment_id>/actions') rest_api.add_resource(RiskAssessmentActionResource, '/api/risk_assessment_action/<int:risk_assessment_action_id>') rest_api.add_resource(HazardResource, '/api/hazards') rest_api.add_resource(HazardDetailsResource, '/api/hazards/<int:hazard_id>')
abort(403, message=err.message) class LotDeceasedResource(Resource): """ Resource for Deceased Lots """ def post(self, lot_id): """ POST /api/lots/<lot_id>/deceased """ form_data = request.json log.debug('Add Deceased for Lot id={0} request: {1}'.format(lot_id, form_data)) # TODO check authenticated user form = AddDeceasedForm.from_json(form_data) try: if form.validate(): data = lot_service.add_occupant(lot_id, form_data) result = dict(status=200, message='OK', deceased=data) return marshal(result, deceased_create_fields) else: abort(400, message="Invalid Parameters", errors=form.errors) except LotPriceNullError as err: abort(403, message=err.message) rest_api.add_resource(LotsResource, '/api/lots') rest_api.add_resource(LotDetailResource, '/api/lots/<int:lot_id>') rest_api.add_resource(BlockLotResource, '/api/blocks/<int:block_id>/lots') rest_api.add_resource(LotDeceasedResource, '/api/lots/<int:lot_id>/deceased') rest_api.add_resource(MarkSoldLotResource, '/api/lots/<int:lot_id>/mark_sold')
abort(403, message=err.message) class LotDeceasedResource(Resource): """ Resource for Deceased Lots """ def post(self, lot_id): """ POST /api/lots/<lot_id>/deceased """ form_data = request.json log.debug('Add Deceased for Lot id={0} request: {1}'.format( lot_id, form_data)) # TODO check authenticated user form = AddDeceasedForm.from_json(form_data) try: if form.validate(): data = lot_service.add_occupant(lot_id, form_data) result = dict(status=200, message='OK', deceased=data) return marshal(result, deceased_create_fields) else: abort(400, message="Invalid Parameters", errors=form.errors) except LotPriceNullError as err: abort(403, message=err.message) rest_api.add_resource(LotsResource, '/api/lots') rest_api.add_resource(LotDetailResource, '/api/lots/<int:lot_id>') rest_api.add_resource(BlockLotResource, '/api/blocks/<int:block_id>/lots') rest_api.add_resource(LotDeceasedResource, '/api/lots/<int:lot_id>/deceased') rest_api.add_resource(MarkSoldLotResource, '/api/lots/<int:lot_id>/mark_sold')
""" Resource for Section Blocks """ @marshal_with(block_basic_fields) def get(self, section_id): """ GET /api/sections/section_id/blocks """ log.debug("Get All Blocks for Section : {0}".format(section_id)) try: return block_service.get_blocks_for_section(section_id) except SectionNotFoundError as err: abort(403, message=err.message) def post(self, section_id): """ POST /api/sections/<section_id>/blocks """ form_data = request.json log.debug('Add Block for Section id={0} request: {1}'.format( section_id, form_data)) # TODO check authenticated user form = AddBlockForm.from_json(form_data) if form.validate(): block = block_service.create_from_dict(section_id, form_data) result = dict(status=200, message='OK', block=block) return marshal(result, block_create_fields) else: abort(400, message="Invalid Parameters", errors=form.errors) rest_api.add_resource(BlocksResource, '/api/blocks') rest_api.add_resource(SectionBlocksResource, '/api/sections/<int:section_id>/blocks')
from flask.ext.restful import Resource, abort, marshal, marshal_with from app.fields.lot_fields import ok_response from app.exceptions.deceased import * from app import rest_api from app.services import deceased_service import logging log = logging.getLogger(__name__) class DeceasedResource(Resource): """ Resource for Deceased """ def delete(self, deceased_id): """ GET /api/deceased/deceased_id """ try: deceased_service.delete_deceased(deceased_id) result = dict(status=200, message='OK') return marshal(result, ok_response) except DeceasedNotFoundError as err: abort(403, message=err.message) rest_api.add_resource(DeceasedResource, '/api/deceased/<int:deceased_id>')
from app import rest_api from applicationModel import api as form_api from users import api as users_api from responses import api as responses_api from content import api as content_api from files import api as files_api from events import api as events_api from reviews import api as reviews_api from invitedGuest import api as invitedGuest_api from registration import api as registration_api from registrationResponse import api as registration_response from guestRegistrations import api as guest_registration from invitationletter import api as invitation_letter_api from attendance import api as attendance_api rest_api.add_resource(users_api.UserAPI, '/api/v1/user') rest_api.add_resource(users_api.UserCommentAPI, '/api/v1/user-comment') rest_api.add_resource(users_api.AuthenticationAPI, '/api/v1/authenticate') rest_api.add_resource(users_api.PasswordResetRequestAPI, '/api/v1/password-reset/request') rest_api.add_resource(users_api.PasswordResetConfirmAPI, '/api/v1/password-reset/confirm') rest_api.add_resource(users_api.AdminOnlyAPI, '/api/v1/admin') rest_api.add_resource(users_api.EmailerAPI, '/api/v1/admin/emailer') rest_api.add_resource(form_api.ApplicationFormAPI, '/api/v1/application-form') rest_api.add_resource(responses_api.ResponseAPI, '/api/v1/response') rest_api.add_resource(content_api.CountryContentAPI, '/api/v1/content/countries') rest_api.add_resource(files_api.FileUploadAPI, '/api/v1/file') rest_api.add_resource(content_api.CategoryContentAPI, '/api/v1/content/categories')
def post(self, audit_id): """ POST /api/audits/<audit_id>/signature """ log.debug("POST Upload Audit Signature Photo request id={0} {1}".format(audit_id, request.files)) uploaded_file = request.files['file'] print "uploaded file: {0}".format(uploaded_file) try: audit = sign_audit(audit_id, uploaded_file) result = dict(status=200, message="OK", audit=audit) return marshal(result, audit_create_fields) except AuditNotFoundError as err: abort(404, message=err.message) def put(self, audit_id): """ PUT /api/audits/<audit_id>/signature """ log.debug("PUT Upload Audit Signature Photo request id={0} files={1} form data={2}".format(audit_id, request.files, request.form)) uploaded_file = request.files['file'] signature_id = request.form.get('signature[id]') try: signature = update_audit_signature(audit_id, signature_id, uploaded_file) result = dict(status=200, message="OK", signature=signature) return marshal(result, signature_create_fields) except (AuditNotFoundError, AuditSignatureNotFoundError) as err: abort(404, message=err.message) rest_api.add_resource(AuditTemplatesResource, '/api/audit_templates') rest_api.add_resource(AuditTemplateDetailsResource, '/api/audit_templates/<int:audit_template_id>') rest_api.add_resource(AuditsResource, '/api/audits') rest_api.add_resource(AuditDetailsResource, '/api/audits/<int:audit_id>') rest_api.add_resource(AuditSignatureResource, '/api/audits/<int:audit_id>/signature')