from fw.auth.social_services import SocialServiceBackends
from fw.db.sql_base import db as sqldb
from fw.documents.address_enums import RFRegionsEnum
from fw.documents.batch_manager import BatchManager
from fw.documents.db_fields import DocumentBatchDbObject
from fw.documents.fields.general_doc_fields import DocAddressField
from fw.documents.fields.simple_doc_fields import DocDateTimeField
from services.notarius.data_model.models import NotariusObject, NotariusBookingObject
notarius_bp = Blueprint('notarius', __name__)
@notarius_bp.route('/meeting/notarius/', methods=['GET'])
@api_view
@login_required
@validate_arguments(batch_id=ArgumentValidator())
def notarius_list(batch_id=None):
batch = DocumentBatchDbObject.query.filter_by(id=batch_id,
_owner=current_user,
deleted=False).scalar()
if not batch:
raise errors.InvalidParameterValue('batch_id')
batch_manager = BatchManager.init(batch)
assert batch_manager
region = batch_manager.get_batch_region(batch_id)
if not region:
return {'result': []}
query = NotariusObject.query.filter_by(region=region)
ifns_bp = Blueprint('ifns', __name__)
_okvad_to_json = lambda x: {
'_id': x.id,
'okved': x.okved,
'caption': x.caption,
'nalog': x.nalog,
'parent': x.parent
}
@ifns_bp.route('/get_okvad/', methods=['POST'])
@api_view
@validate_arguments(
parent=ArgumentValidator(required=False),
batch_type=ArgumentValidator(required=False),
search=ArgumentValidator(required=False)
)
def get_okvad(parent=None, batch_type=None, search=None):
search = search or ""
make_okvad = lambda x: x['class'] + (
('.%s' % x['group'] + ('.%s' % x['kind'] if 'kind' in x else '')) if 'group' in x else '')
query = OkvadObject.query.filter()
if parent:
query = query.filter_by(parent=parent)
if search:
query = query.filter(OkvadObject.caption.ilike(u'%%%s%%' % search))
result = [_okvad_to_json(item) for item in query]
from fw.api import errors
from fw.api.args_validators import validate_arguments, ArgumentValidator
from fw.api.base_handlers import api_view
from fw.db.sql_base import db as sqldb
from fw.documents.db_fields import DocumentBatchDbObject
from services.russian_post.db_models import RussianPostTrackingItem
russian_post_bp = Blueprint('russian_post_bp', __name__)
@russian_post_bp.route('/external/russianpost/mail/status/', methods=['GET'])
@api_view
@login_required
@validate_arguments(
batch_id=ArgumentValidator(required=True),
#tracking=ArgumentValidator(required=True)
)
def get_mail_status(batch_id=None):
tracking = RussianPostTrackingItem.query.filter(
RussianPostTrackingItem.batch_id == batch_id,
RussianPostTrackingItem.owner_id != 111111
).first() # not scalar
if not tracking:
raise errors.PostTrackingItemNotFound()
return {'result': {
'status': tracking.status,
'status_caption': tracking.status_caption
}}
try:
if not batch_manager.finalize_batch(current_app.config,
current_app.logger, batch):
raise errors.DocumentBatchFinalizationError()
except Exception:
current_app.logger.exception(u"Finalisation error")
return {"result": False}
return {"result": True}
@documents_bp.route('/batch/finalise/', methods=['POST'])
@api_view
@login_required
@validate_arguments(batch_id=ArgumentValidator())
def finalize_batch(batch_id=None):
batch = DocumentBatchDbObject.query.filter_by(id=batch_id,
_owner=current_user,
deleted=False).first()
if not batch:
raise errors.BatchNotFound()
return _finalize_batch(batch)
@documents_bp.route('/batch/finalise/cancel/', methods=['POST'])
@api_view
@login_required
@validate_arguments(batch_id=ArgumentValidator())
def cancel_batch_finalization(batch_id=None):
batch = DocumentBatchDbObject.query.filter_by(id=batch_id,
] and 'city_type' in item and item['city_type'] == u"г":
item['city'] = None
item['city_type'] = None
item['city_type_full'] = None
resp = Response(json.dumps(data), mimetype='application/json')
_set_cors_headers(resp)
current_app.logger.debug(u"suggest finished")
return resp
except Exception:
pass
resp = Response('[]', mimetype='application/json')
_set_cors_headers(resp)
return resp
@general_bp.route('/geoip/', methods=['GET'])
@api_view
@validate_arguments(ip=ArgumentValidator(required=False))
def geo_ip(ip=None):
ip = ip or request.remote_addr
try:
result = geoip_utils.GeoIpLocator.get_location(ip)
if not result:
raise Exception()
except Exception:
current_app.logger.exception(u"Failed to get location")
return {'result': {'region': RFRegionsEnum.RFR_SPB}}
return {'result': result}
return result
@auth_bp.route('/account/profile/', methods=['GET'])
@api_view
@login_required
def get_profile():
data = get_user_api_structure(current_user)
return {"result": data}
@auth_bp.route('/account/confirm/', methods=['POST', 'GET'])
@api_view
@validate_arguments(code=ConfirmationCodeValidator(),
user_id=ArgumentValidator(required=False))
def confirm_account(code=None, user_id=None):
if len(code) != current_app.config['max_activation_link_length'] and \
len(code) != current_app.config['digital_activation_link_length']:
raise errors.InvalidParameterValue('code')
if len(code) == current_app.config['digital_activation_link_length'] and not user_id:
raise errors.MissingRequiredParameter('code')
link_type = ConfirmationLinkTypeEnum.CLT_MOBILE if (
len(code) == current_app.config['digital_activation_link_length']) else ConfirmationLinkTypeEnum.CLT_EMAIL
user = UserManager.confirm_email_or_mobile(code, user_id if user_id else None, link_type)
if not user:
raise errors.UserNotFound()
data = get_user_api_structure(user)
from fw.db.sql_base import db as sqldb
from fw.documents.db_fields import DocumentBatchDbObject
from fw.storage.file_storage import FileStorage
from services.yurist import yurist_manager
from services.yurist.data_model.enums import YuristBatchCheckStatus
from services.yurist.data_model.fields import YuristBatchCheck
from services.yurist.data_model.models import YuristBatchCheckObject, YuristCheckFilesObject
yurist_bp = Blueprint('yurist', __name__)
@yurist_bp.route('/batch/yurist/set/', methods=['POST'])
@api_view
@login_required
@validate_arguments(
batch_id=ArgumentValidator(required=True),
check=BoolTypeValidator(required=True),
file_list=ArgumentValidator(required=False),
typos_correction=BoolTypeValidator(required=False)
)
def yurist_set(batch_id=None, check=None, file_list=None, typos_correction=False):
typos_correction = bool(typos_correction)
batch_db = DocumentBatchDbObject.query.filter_by(id=batch_id, _owner=current_user, deleted=False).first()
if not batch_db:
raise errors.BatchNotFound()
if check:
new = True
# search for any active check
cur_check_obj = YuristBatchCheckObject.query.filter(
YuristBatchCheckObject.batch_id == batch_id,
result += u"\n\n"
for i in xrange(min(len(res), 10)):
result += "\n%s" % unicode(res[i].bysize)
result += u"\n\n"
for i in xrange(min(len(res), 10)):
result += "\n%s" % unicode(res[i].byclodo)
result += u"\n\n"
for i in xrange(min(len(res), 10)):
result += "\n%s" % unicode(res[i].byid)
return u"<html><body><pre>%s</pre></body></html>" % result
@system_bp.route('/sys/get_batch_doc/', methods=['GET'])
@api_view
@validate_arguments(batch_id=ArgumentValidator(required=True), document_id=ArgumentValidator(required=True))
def get_batch_doc(batch_id=None, document_id=None):
config = current_app.config
if not config['STAGING'] and not config['DEBUG']:
abort(404)
batch = DocumentBatchDbObject.query.filter_by(id=batch_id).first()
if not batch:
raise errors.BatchNotFound()
doc = BatchDocumentDbObject.query.filter_by(id=document_id).first()
file_obj = doc.file
if file_obj:
file_path = FileStorage.get_path(file_obj, current_app.config)
if os.path.exists(file_path) and file_path.endswith('.pdf'):
file_path = file_path[:-4] + '.text-src'
from fw.documents.fields.doc_fields import DocumentBatch
from fw.documents.schema.conditions import Condition
from fw.api import errors
from fw.api.args_validators import validate_arguments, ArgumentValidator
from fw.api.base_handlers import api_view
from fw.documents.batch_manager import BatchManager
from services.partners.models import AccountantPartnersObject, BankPartnersObject, BankPartnerRequestObject, \
BankPartnersServiceObject, StampPartnersObject
partners_bp = Blueprint('partners', __name__)
@partners_bp.route('/partners/accounts/', methods=['GET'])
@api_view
@login_required
@validate_arguments(batch_id=ArgumentValidator())
def get_accountant_partners(batch_id=None):
accountant_partner_list = []
try:
region = BatchManager.get_batch_region(batch_id)
except Exception, ex:
current_app.logger.exception(u"Failed to get batch region")
raise errors.BatchNotFound()
partners = AccountantPartnersObject.query.filter_by(enabled=True)
if region:
partners = partners.filter(
or_(AccountantPartnersObject.region.contains([region]),
AccountantPartnersObject.region == None))
for item in partners.order_by(AccountantPartnersObject.sort_index.asc()):
# -*- coding: utf-8 -*-
from flask import Blueprint
from flask_login import login_required
from fw.api import errors
from fw.api.args_validators import validate_arguments, ArgumentValidator, IntValidator
from fw.api.base_handlers import api_view
from services.car_assurance.db_models import CarAssurance, CarAssuranceBranch
car_assurance_bp = Blueprint('car_assurance', __name__)
@car_assurance_bp.route('/structures/insurances/', methods=['GET'])
@api_view
@login_required
@validate_arguments(type=ArgumentValidator(required=True),
search=ArgumentValidator(required=False),
limit=IntValidator(required=False,
min_val=1,
max_val=100500),
offset=IntValidator(required=False,
min_val=0,
max_val=100500))
def get_car_insurances(search=None, limit=100, offset=0, **kwargs):
if 'type' not in kwargs:
raise errors.MissingRequiredParameter('type')
type_arg = kwargs['type']
if type_arg != 'osago':
raise errors.InvalidParameterValue('type')
if search: