def render_batch_documents(batch_id=None, document_type=None):
batch = DocumentBatchDbObject.query.filter_by(id=batch_id,
_owner=current_user,
deleted=False).first()
if not batch:
raise errors.BatchNotFound()
batch_manager = BatchManager.init(batch)
document_types = json.loads(document_type)
if not isinstance(document_types, list) and not isinstance(
document_types, tuple):
raise errors.InvalidParameterValue('document_type')
doc_type_set = set()
for doc_type in document_types:
if not batch_manager.check_doc_type_support(batch.batch_type,
doc_type):
raise errors.InvalidParameterValue('document_type')
doc_type_set.add(doc_type)
action_descriptor = {'plugin': 'doc_builder', 'action': 'render_group'}
event_data = {'doc_types': list(doc_type_set), 'batch_id': batch.id}
BatchManager.perform_action(action_descriptor, batch, event_data,
current_app.logger, current_app.config)
return {"result": True}
def get_render_batch_documents_state(batch_id=None, document_types=None):
batch = DocumentBatchDbObject.query.filter_by(id=batch_id,
_owner=current_user,
deleted=False).first()
if not batch:
raise errors.BatchNotFound()
batch_manager = BatchManager.init(batch)
try:
document_types = json.loads(document_types)
if not isinstance(document_types, list) and not isinstance(
document_types, tuple):
raise Exception()
except Exception:
raise errors.InvalidParameterValue('document_type')
doc_type_set = set()
for doc_type in document_types:
if not batch_manager.check_doc_type_support(batch.batch_type,
doc_type):
raise errors.InvalidParameterValue('document_type')
doc_type_set.add(doc_type)
result = []
for doc_type in doc_type_set:
doc_obj = BatchDocumentDbObject.query.filter_by(
batch_id=batch_id, document_type=doc_type).first()
if not doc_obj:
result.append({
'state': UserDocumentStatus.DS_NEW,
'document_type': doc_type
})
continue
doc_info = {'state': doc_obj.status, 'document_type': doc_type}
if doc_obj.status == UserDocumentStatus.DS_RENDERED:
if doc_obj.file:
doc_info['links'] = {
'pdf': FileStorage.get_url(doc_obj.file,
current_app.config),
'jpeg': []
}
result.append(doc_info)
else:
current_app.logger.debug(
u"Not found rendered documents for rendered document %s. "
u"Returning as rendering_failed" % doc_type)
result.append({
'state': UserDocumentStatus.DS_RENDERING_FAILED,
'document_type': doc_type
})
else:
result.append(doc_info)
return result
def get_company_person_data_for_ifns(founder_applicant, reg_responsible_object, email):
person_data = None
company_data = None
reg_responsible_person = None
try:
if reg_responsible_object and '_id' in reg_responsible_object and 'type' in reg_responsible_object:
obj_id = reg_responsible_object['_id']
obj_type = reg_responsible_object['type']
if obj_type == 'person':
reg_responsible_person = obj_id
else:
reg_responsible_company = CompanyDbObject.query.filter_by(id=obj_id).scalar()
if reg_responsible_company and reg_responsible_company.general_manager:
reg_responsible_person = reg_responsible_company.general_manager['_id']
except Exception:
pass
if reg_responsible_person:
person_obj = PrivatePersonDbObject.query.filter_by(id=reg_responsible_person).scalar()
if not person_obj:
raise errors.InvalidParameterValue("reg_responsible_person")
person_data = {
"name": person_obj.name or u"",
"surname": person_obj.surname or u"",
"patronymic": person_obj.patronymic or u"",
"phone": person_obj.phone,
"email": email,
"inn": person_obj.inn
}
return None, person_data
if FounderTypeEnum.TYPE_CLS(founder_applicant['founder_type']) == FounderTypeEnum.FT_PERSON:
person_obj = PrivatePersonDbObject.query.filter_by(id=founder_applicant['person']['_id']).scalar()
if not person_obj:
raise errors.InvalidParameterValue("founder_applicant")
person_data = {
"name": person_obj.name or u"",
"surname": person_obj.surname or u"",
"patronymic": person_obj.patronymic or u"",
"phone": person_obj.phone,
"email": email,
"inn": person_obj.inn
}
else:
company_obj = CompanyDbObject.query.filter_by(id=founder_applicant['company']['_id']).scalar()
general_manager = company_obj.general_manager
if not general_manager or not company_obj:
raise errors.InvalidParameterValue("founder_applicant")
company_data = {
"name": company_obj.full_name,
"phone": general_manager.phone,
"email": email,
"inn": company_obj.inn
}
return company_data, person_data
def create_company(company=None):
try:
company_doc = CompanyObject.parse_raw_value(company, api_data=True)
if not company_doc:
raise Exception()
except Exception:
current_app.logger.exception(u"Failed to validate company data")
raise errors.InvalidParameterValue('company')
try:
company_doc.validate(strict=False)
except Exception, ex:
raise errors.InvalidParameterValue('company')
def notarius_schedule(notarius_id=None, **kwargs):
empty_result = {'result': {"nearest_time": None, "slots": []}}
dt = kwargs.get('datetime', None)
if not dt:
raise errors.InvalidParameterValue('datetime')
notarius_db = NotariusObject.query.filter_by(id=notarius_id).scalar()
if not notarius_db:
raise errors.NotariusNotFound()
now = datetime.utcnow()
two_weeks = timedelta(14)
dt = datetime(dt.year, dt.month, dt.day)
if dt < now or dt > now + two_weeks:
return empty_result
day_from, day_to = dt, dt + timedelta(days=1)
days = NotariusObject.get_notarius_schedule(notarius_db,
day_from=day_from,
day_to=day_to)
days = filter(lambda y: y['slots'],
sorted(days, key=lambda x: x['nearest_time']))
days = filter(
lambda x: datetime.strptime(x['nearest_time'], DocDateTimeField.FORMAT)
.date() == dt.date(), days)
if not days:
return empty_result
return {'result': days[0]}
def _validate(arg_name, validator, required_args):
if isinstance(validator, ArgumentValidator):
validator.application = current_app
try:
if not len(request.form) and not len(
request.args) and request.data:
from werkzeug.urls import url_decode
args = url_decode(request.data)
if arg_name not in args:
raise KeyError(arg_name)
value = args[arg_name]
else:
value = request.form[
arg_name] if arg_name in request.form else request.args[
arg_name]
if not validator.validate(value):
raise errors.InvalidParameterValue(arg_name)
except KeyError:
if validator.required:
raise errors.MissingRequiredParameter(arg_name)
value = validator.default_value
required_args[arg_name] = validator.get_value(
value) if value is not None else None
else:
raise ValueError(
"Invalid parameter in argument validator description: %s" %
str(validator))
def notarius_list_by_region(region=None):
if not RFRegionsEnum.validate(region):
raise errors.InvalidParameterValue('region')
query = NotariusObject.query.filter_by(region=region)
result = [item.get_api_structure() for item in query]
return {'result': result}
def create_person(person=None):
try:
person_doc = PrivatePerson.parse_raw_value(person, api_data=True)
if not person_doc:
raise Exception()
except Exception, ex:
raise errors.InvalidParameterValue('person')
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:
query = CarAssurance.query.filter_by(full_name=search).order_by(
CarAssurance.full_name)
else:
query = CarAssurance.query.filter().order_by(CarAssurance.short_name)
total = query.count()
query = query.limit(limit).offset(offset)
count = query.count()
result = {
'total':
total,
'count':
count,
'insurances': [{
"id": i.id,
"short_name": i.short_name,
"full_name": i.full_name
} for i in query]
}
return {'result': result}
def get_external_login_url(social_network=None):
if social_network not in ('facebook', 'vk', 'google'):
raise errors.InvalidParameterValue('social_network')
backend = SocialServiceBackends.backends.get(social_network)
if not backend:
raise errors.InvalidParameterValue('social_network')
config = current_app.config
next_page = request.args['next_page']
if '?' in next_page:
next_page = next_page.split('?')[0]
current_app.logger.debug(u"2 redirect url: %s" % next_page)
token_url = backend.get_token_url(config, next_page=next_page)
return {"result": token_url}
def batch_create(batch_type=None):
try:
DocRequisitiesStorage.get_batch_descriptor(batch_type)
except Exception:
raise errors.InvalidParameterValue('batch_type')
batch_manager = BatchManager.init(batch_type=batch_type)
new_batch = batch_manager.create_batch(current_user)
sqldb.session.add(new_batch)
sqldb.session.commit()
doc_batch = DocumentBatch.db_obj_to_field(new_batch)
return {'result': doc_batch.get_api_structure()}
def ifns_get_reservations(batch_id=None):
batch_db = DocumentBatchDbObject.query.filter_by(id=batch_id, _owner=current_user, deleted=False).scalar()
if not batch_db:
raise BatchNotFound()
if batch_db.status != BatchStatusEnum.BS_FINALISED:
raise errors.InvalidParameterValue('batch_id')
booking = IfnsBookingObject.query.filter(
IfnsBookingObject.batch_id == batch_id,
IfnsBookingObject._discarded == False,
IfnsBookingObject.reg_info.__ne__(None)
).first()
try:
name = batch_db.data['full_name']
full_name = u"Общество с ограниченной ответственностью \"%s\"" % name
except Exception:
current_app.logger.exception(u"Failed to collect data")
raise errors.InvalidParameterValue('batch_id')
if not booking:
return {
'result': {
'full_name': full_name,
'status': "unknown"
}
}
result = {'result': {
'full_name': full_name,
'status': booking.reg_info.get('status', 'unknown')
}}
reg_date = booking.reg_info.get('reg_date', None)
ogrn = booking.reg_info.get('ogrn', None)
if reg_date:
result['result']['reg_date'] = reg_date
if ogrn:
result['result']['ogrn'] = booking.reg_info.get('ogrn', None)
return result
def get_bank_partner_request_status(bank_id=None, batch_id=None):
try:
bank_id = ObjectId(bank_id)
except Exception:
raise errors.InvalidParameterValue('bank_id')
try:
ObjectId(batch_id)
except Exception:
raise errors.InvalidParameterValue('batch_id')
current_bank_request = BankPartnerRequestObject.query.filter_by(
bank_partner_id=bank_id, batch_id=batch_id).first()
if not current_bank_request:
raise errors.BatchNotFound()
if current_bank_request and current_bank_request.status == 'sending' and \
abs((datetime.utcnow() - current_bank_request.sent_date).total_seconds()) > 60:
sqldb.session.delete(current_bank_request)
sqldb.session.commit()
raise errors.BatchNotFound()
return {"result": current_bank_request['status']}
def password_change(user_id=None, email=None, code=None, old_password=None, new_password=None):
email = email.lower() if email else u""
if not user_id and email:
# find user based on email
user = AuthUser.query.filter_by(email=email).first()
if not user:
raise errors.UserNotFound()
user_id = user.uuid
elif not user_id:
raise errors.InvalidParameterValue('user_id')
user = UserManager.change_password(user_id, code, old_password, new_password)
if user and not current_user.is_authenticated:
login_user(user)
return {"result": True}
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)
return {"result": data}
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)
result = [item.get_api_structure() for item in query]
return {'result': result}
def ifns_get_name(ifns=None):
null_res = {'result': {
'title': "",
'has_booking': False,
'address': None
}}
IFNS_LOGGER.debug("ifns_get_name")
try:
ifns = int(ifns)
if ifns < 1 or ifns > 99999:
raise ValueError()
except Exception:
raise errors.InvalidParameterValue('ifns')
result = IfnsCatalogObject.query.filter_by(code=ifns).first()
if not result:
return null_res
ifns_item = result
if not ifns_item.rou:
return null_res
rou = ifns_item.rou
if not rou or 'name' not in rou:
return null_res
title = rou['name']
if not title:
return null_res
has_booking = (7700 <= ifns <= 7799) or (7800 <= ifns <= 7899) # or (4700 <= ifns <= 4799)
address = (ifns_item.rou or {}).get('address', {})
if not isinstance(address, dict):
address = {}
return {'result': {
"title": title,
"has_booking": has_booking,
"address": address
}}
def get_dep_okvads(department_id=None, batch_type=None):
from services.ip_reg.okvad_utils import is_restricted_for_ip_okvad
for c in OkvedCatalogObject.query.filter():
if not c.departments:
continue
for dep in c.departments:
if dep['id'] == department_id:
okvad_list = dep['okvads']
if not okvad_list:
continue
result = [_okvad_to_json(item) for item in OkvadObject.query.filter(OkvadObject.okved.in_(okvad_list))]
for i in xrange(len(result)):
result[i]['description'] = ""
code = result[i]['okved']
result[i]['code'] = code
del result[i]['okved']
if batch_type == DocumentBatchTypeEnum.DBT_NEW_IP:
result = filter(lambda x: not is_restricted_for_ip_okvad(x['code']), result)
return {'result': result}
raise errors.InvalidParameterValue('department_id')
def track_mail_status(batch_id=None, tracking=None):
tracking = tracking.strip()
if not tracking:
raise errors.InvalidParameterValue('tracking')
tracking_item = RussianPostTrackingItem.query.filter(
RussianPostTrackingItem.batch_id == batch_id,
RussianPostTrackingItem.tracking == tracking,
RussianPostTrackingItem.owner_id != 111111
).first()
if tracking_item:
return {
'result': True
}
RussianPostTrackingItem.query.filter(
RussianPostTrackingItem.batch_id == batch_id,
RussianPostTrackingItem.owner == current_user
).delete()
sqldb.session.commit()
batch = DocumentBatchDbObject.query.filter_by(id=batch_id, deleted=False).scalar()
if not batch:
raise errors.BatchNotFound()
new_tracking = RussianPostTrackingItem(
batch=batch,
owner=current_user,
tracking=tracking
)
sqldb.session.add(new_tracking)
sqldb.session.commit()
from services.russian_post.async_tasks import get_tracking_info_async
get_tracking_info_async.delay(batch_id=batch.id)
return {'result': True}
@domain_objects_bp.route('/entity/person/create/', methods=['POST'])
@api_view
@login_required
@validate_arguments(person=JsonValidator())
def create_person(person=None):
try:
person_doc = PrivatePerson.parse_raw_value(person, api_data=True)
if not person_doc:
raise Exception()
except Exception, ex:
raise errors.InvalidParameterValue('person')
try:
person_doc.validate(strict=False)
except Exception, ex:
raise errors.InvalidParameterValue('person')
person = person_doc.get_db_object()
person._owner = current_user
sqldb.session.add(person)
sqldb.session.commit()
result = person_doc.get_api_structure()
result['id'] = person.id + "_person"
return {"result": result}
@domain_objects_bp.route('/entity/person/', methods=['GET'])
@api_view
@login_required
def signup(email=None, access_token=None, password=None, social_network=None):
if "X-Forwarded-For" in request.headers and request.headers.getlist("X-Forwarded-For"):
ip = request.headers.getlist("X-Forwarded-For")[0]
elif "X-Real-Ip" in request.headers and request.headers.getlist("X-Real-Ip"):
ip = request.headers.getlist("X-Real-Ip")[0]
else:
ip = request.remote_addr
if ip in current_app.config['OFFICE_IP']:
is_test_user = True
else:
is_test_user = False
if not email and not access_token:
raise errors.MissingRequiredParameter('email')
if not EmailAddressValidator().validate(email) and not access_token:
raise errors.InvalidParameterValue('email')
if access_token:
password = ''
if social_network and social_network not in SocialServiceEnum.TAG_ALL:
raise errors.InvalidParameterValue('social_network')
if not PasswordValidator().validate(password) and not access_token:
raise errors.MissingRequiredParameter('password')
if current_user and not current_user.is_anonymous:
if not current_user.temporal:
raise errors.InvalidParameterValue('email')
new_user = UserManager.promote_temp_user(current_user, access_token, None, email, u"", u"", u"", password, social_network)
new_user.is_tester = is_test_user
else:
new_user = UserManager.register_user(access_token, None, email, u"", u"", u"", password, social_network)
new_user.is_tester = is_test_user
google_client_id = request.cookies.get('_ga_cid')
if google_client_id and not new_user.temporal:
metrics.update_user_info(new_user, google_client_id=google_client_id)
new_user.email = new_user.email.lower() if new_user.email else u""
data = get_user_api_structure(new_user)
result = {"result": data}
if not email and access_token:
login_user(new_user)
my_resp = MyResp()
current_app.session_interface.save_session(current_app, flask.session, my_resp)
return result
user = UserManager.login_user(email, password)
if user:
login_user(user)
my_resp = MyResp()
current_app.session_interface.save_session(current_app, flask.session, my_resp)
user.last_login_date = datetime.utcnow()
return result
def ifns_reserve(ifns=None, service=None, batch_id=None, **kwargs):
dt = kwargs['datetime']
service = int(service)
result = None
batch_db = DocumentBatchDbObject.query.filter_by(id=batch_id, _owner=current_user, deleted=False).scalar()
if not batch_db:
raise errors.InvalidParameterValue('batch_id')
from services.llc_reg.llc_reg_manager import LlcRegBatchManager
founder_applicant = LlcRegBatchManager.get_founder_applicant(batch_db, logger=current_app.logger)
if not founder_applicant:
raise errors.InvalidParameterValue("batch_id")
reg_responsible_object = LlcRegBatchManager.get_reg_responsible_object(batch_db, logger=current_app.logger)
if not batch_db.data:
raise errors.InvalidParameterValue('batch_id')
batch_data_data = batch_db.data
if 'full_name' not in batch_data_data or not batch_data_data['full_name']:
raise errors.InvalidParameterValue('batch_id')
company_full_name = batch_data_data['full_name']
ifns_data = ifns_manager.get_ifns_data(ifns)
if not ifns_data or not ifns_data.rou:
raise errors.InvalidParameterValue("ifns")
rou = ifns_data.rou
if 'code' not in rou:
raise errors.InvalidParameterValue("ifns")
code = rou['code']
if service == IfnsServiceEnum.IS_REG_COMPANY:
if code not in LLC_REG_INTERNAL_SERVICE_ID_MAP:
raise errors.InvalidParameterValue("ifns")
IFNS_LOGGER.debug(
u"Trying to reserve ifns. ifns:%d, service:%s, dt:%s" % (int(ifns), unicode(service), unicode(dt)))
company_data, person_data = get_company_person_data_for_ifns(founder_applicant, reg_responsible_object,
current_user.email)
obj_type = "person" if person_data is not None else "company"
internal_ifns_service, internal_ifns_number = LLC_REG_INTERNAL_SERVICE_ID_MAP[code][obj_type]
try:
result = current_app.external_tools.book_ifns(person_data, company_data, internal_ifns_number,
internal_ifns_service, dt, IFNS_LOGGER)
except Exception:
IFNS_LOGGER.exception(u"Failed to reserve ifns.")
raise
elif service == IfnsServiceEnum.IS_RECEIVE_REG_DOCS:
try:
if code not in RECEIVE_REG_DOCS_INTERNAL_SERVICE_ID_MAP:
raise errors.InvalidParameterValue("ifns")
general_manager = batch_data_data.get('general_manager')
if not general_manager or '_id' not in general_manager:
raise errors.InvalidParameterValue("batch_id")
general_manager_id = general_manager['_id']
general_manager_obj = PrivatePersonDbObject.query.filter_by(id=general_manager_id).scalar()
if not general_manager_obj:
raise errors.InvalidParameterValue("batch_id")
internal_ifns_service, internal_ifns_number = RECEIVE_REG_DOCS_INTERNAL_SERVICE_ID_MAP[code]
company_data = {
'inn': '0000000000',
"name": company_full_name,
"phone": general_manager_obj.phone,
"email": current_user.email,
}
result = current_app.external_tools.book_ifns(None, company_data, internal_ifns_number,
internal_ifns_service, dt, IFNS_LOGGER)
except Exception:
IFNS_LOGGER.exception(u"Failed to reserve ifns.")
raise
if result:
from fw.async_tasks import send_email
try:
booking = IfnsBookingObject(
batch_id=batch_id,
code=result['code'],
date=result['date'],
service=result['service'],
phone=result['phone'],
window=result['window'],
address=result['address'],
service_id=service,
ifns=result['ifns'],
how_to_get=result['how_to_get']
)
sqldb.session.add(booking)
sqldb.session.commit()
IFNS_LOGGER.debug(u"Reserverd ifns. booking id: %s" % booking.id)
social_link = SocialServiceBackends.get_user_social_network_profile_url(current_user.id)
rec_list = current_app.config['YURIST_EMAIL_LIST']
llc_full_name = batch_db.data.get('full_name', "")
docs = BatchManager.get_shared_links_to_rendered_docs(batch_db, current_app.config,
IFNS_LOGGER)
for recipient in rec_list:
send_email.send_email.delay(
recipient,
'ifns_reservation_notification',
email=current_user.email,
mobile=current_user.mobile,
social_link=social_link,
full_name=llc_full_name,
ifns=result['ifns'],
booking_time=result['date'],
docs=docs
)
booking_field = IfnsBooking.db_obj_to_field(booking)
return {'result': booking_field.get_api_structure()}
except Exception, ex:
IFNS_LOGGER.exception(u"Failed to save booking!")
raise errors.ServerError()
def ifns_schedule(ifns=None, service=None, batch_id=None, **kwargs):
dt = kwargs['datetime']
service = int(service)
batch_db = DocumentBatchDbObject.query.filter_by(id=batch_id, _owner=current_user, deleted=False).scalar()
if not batch_db:
raise errors.InvalidParameterValue('batch_id')
# todo: check batch type (new llc)
from services.llc_reg.llc_reg_manager import LlcRegBatchManager
founder_applicant = LlcRegBatchManager.get_founder_applicant(batch_db, logger=current_app.logger)
if not founder_applicant:
raise errors.InvalidParameterValue("batch_id")
IFNS_LOGGER.debug(
u"Trying to get ifns schedule. ifns:%d, service:%s, dt:%s" % (int(ifns), unicode(service), unicode(dt)))
all_time_slots = []
ifns_data = ifns_manager.get_ifns_data(ifns)
if not ifns_data or not ifns_data.rou:
raise errors.InvalidParameterValue("ifns")
rou = ifns_data.rou
if 'code' not in rou:
raise errors.InvalidParameterValue("ifns")
code = rou['code']
if service == IfnsServiceEnum.IS_REG_COMPANY:
if code not in LLC_REG_INTERNAL_SERVICE_ID_MAP:
raise errors.InvalidParameterValue("ifns")
# noinspection PyTypeChecker
company_data, person_data = get_company_person_data_for_ifns(founder_applicant, None, current_user.email)
obj_type = "person" if person_data is not None else "company"
internal_ifns_service, internal_ifns_number = LLC_REG_INTERNAL_SERVICE_ID_MAP[code][obj_type]
try:
all_time_slots = current_app.external_tools.get_nalog_ru_time_slots(person_data,
company_data,
internal_ifns_number,
internal_ifns_service, IFNS_LOGGER)
if not all_time_slots:
raise Exception()
except Exception:
IFNS_LOGGER.exception(u"Failed to get_nalog_ru_time_slots")
raise
elif service == IfnsServiceEnum.IS_RECEIVE_REG_DOCS:
if code not in RECEIVE_REG_DOCS_INTERNAL_SERVICE_ID_MAP:
raise errors.InvalidParameterValue("ifns")
internal_ifns_service, internal_ifns_number = RECEIVE_REG_DOCS_INTERNAL_SERVICE_ID_MAP[code]
company_data = _make_fake_company_data()
try:
all_time_slots = current_app.external_tools.get_nalog_ru_time_slots(None,
company_data,
internal_ifns_number,
internal_ifns_service, IFNS_LOGGER)
if not all_time_slots:
raise Exception()
except Exception:
IFNS_LOGGER.exception(u"Failed to get_nalog_ru_time_slots")
raise
if not all_time_slots:
return {
'result': {
'nearest_time': None,
'slots': []
}
}
td_min = timedelta(seconds=99999999)
nearest_time = datetime.strptime(all_time_slots[0]['date'], "%Y-%m-%d")
slots = all_time_slots[0]['time_slots']
actual_slots = []
dt_str = dt.strftime("%Y-%m-%d")
for slot in all_time_slots:
cur_date = datetime.strptime(slot['date'], "%Y-%m-%d")
if slot['date'] == dt_str:
actual_slots = slot['time_slots']
td_cur = cur_date - dt if (cur_date > dt) else (dt - cur_date)
if td_cur < td_min:
td_min = td_cur
nearest_time = cur_date
slots = slot['time_slots']
# IFNS_LOGGER.debug(u"Ifns schedule - succeeded. Nearest time: %s, Slots: %s" % (nearest_time.strftime("%Y-%m-%d"), json.dumps(slots)))
return {'result': {
'nearest_time': dt_str,
'slots': actual_slots
}}
def login_external(social_network=None, next_page=""):
class MyResp(Response):
def set_cookie(self, key, value='', max_age=None, expires=None,
path='/', domain=None, secure=None, httponly=False):
self.__name = key
self.__val = value
super(MyResp, self).set_cookie(key, value, max_age, expires, path, domain, secure, httponly)
try:
code = request.args['code']
except Exception:
if 'error' in request.args:
html = u"""<html><head></head><body><script>window.location.href = "/";</script></body></html>"""
my_resp = MyResp(html, status=200, content_type="text/html; charset=utf-8")
return my_resp
raise errors.InvalidParameterValue('code')
if social_network not in ('facebook', 'vk', 'google'):
raise errors.InvalidParameterValue('social_network')
backend = SocialServiceBackends.backends.get(social_network)
if not backend:
raise errors.InvalidParameterValue('social_network')
config = current_app.config
if backend:
if '?' in next_page:
next_page = next_page.split('?')[0]
current_app.logger.debug(u"2 redirect url: %s" % next_page)
access_token, ext_data = backend.get_token(code, config, next_page=next_page)
if not access_token:
raise errors.SocialAuthError()
user_data = backend.get_user_data(config, access_token)
social_uid = user_data.get('id')
if not social_uid:
raise errors.SocialAuthError()
social_service_user_link = backend.get_user_link(unicode(social_uid))
if social_service_user_link:
user = social_service_user_link.user
else:
ext_data = ext_data or {}
if 'email' not in ext_data:
ext_data = backend.get_user_data(config, access_token)
user, user_profile = UserManager.create_user(access_token, "", ext_data.get('email', ""), "", "", "", "",
social_network, email_is_social=True)
old_user_id = current_user.id if (
current_user and not current_user.is_anonymous and current_user.temporal) else None
if old_user_id:
new_user_id = user.id
change_account_data_owner(old_user_id, new_user_id)
google_client_id = request.cookies.get('_ga_cid')
if google_client_id and not user.temporal:
metrics.update_user_info(user, google_client_id=google_client_id)
login_user(user)
user.last_login_date = datetime.utcnow()
my_resp = MyResp()
current_app.session_interface.save_session(current_app, flask.session, my_resp)
# noinspection PyUnresolvedReferences
html = u"""
<html>
<head></head>
<body>
<script>
window.location.href = "/%s";
</script>
</body>
</html>
""" % next_page
my_resp = MyResp(html, status=200, content_type="text/html; charset=utf-8")
return my_resp
return {"result": None}
def get_content_on_post(self, arguments=None, *args, **kwargs):
logger = self.application.logger # todo: ifns logger!
cache = self.application.cache
ifns = arguments['ifns']
service = arguments['service']
dt = arguments['datetime']
founder_applicant = arguments['founder_applicant']
service_nalog_ru_url = self.application.config['SERVICE_NALOG_RU_URL']
try:
company_data, person_data = yield AsyncIfnsProvider.get_company_person_data_for_ifns(
founder_applicant, self.user.email, self.application.db)
except Exception:
logger.exception(u"Failed to collect data")
raise errors.InvalidParameterValue("founder_applicant")
try:
reg_ifns = yield AsyncIfnsProvider.get_registration_ifns(
int_to_ifns(ifns),
cache,
service_nalog_ru_url=service_nalog_ru_url)
except Exception:
logger.exception(
u"Failed to get registration ifns. Address ifns: %s" %
unicode(ifns))
raise
reg_ifns_name = reg_ifns['rou']['naimk']
reg_ifns_addr = reg_ifns['adres']
try:
address = yield AsyncDadataProvider.get_detailed_address(
reg_ifns_addr, cache)
if not address:
raise Exception()
except Exception:
logger.exception(
u"Failed to get detailed address. Reg ifns address: %s" %
unicode(reg_ifns_addr))
raise
region_name = address['suggestions'][0]['data']['region']
try:
result = yield AsyncIfnsProvider.get_nalog_ru_time_slots(
person_data, company_data, reg_ifns_name, service, region_name,
cache, logger)
except errors.IfnsServiceUnavailable, ex:
logger.exception(
u"Failed to get schedule from ifns. Trying to get cached value"
)
try:
result = yield AsyncIfnsProvider.get_nalog_ru_time_slots_cached(
not company_data, reg_ifns_name, service, region_name,
cache, logger)
if len(result) < 8:
last_found_day = datetime.strptime(result[-1]['date'],
"%Y-%m-%d")
result += AsyncIfnsProvider.get_nalog_ru_default_time_slots(
region_name,
reg_ifns_name,
not company_data,
first_day=last_found_day,
days_to_get=8 - len(result))
except CacheMiss, ex:
logger.exception(u"Nothing in cache: returning defaults")
result = AsyncIfnsProvider.get_nalog_ru_default_time_slots(
region_name, reg_ifns_name, not company_data)
def request_bank_partner(bank_id=None,
batch_id=None,
bank_contact_phone_general_manager=False,
bank_contact_phone="",
send_private_data=None):
if not bank_contact_phone_general_manager and not bank_contact_phone:
raise errors.MissingRequiredParameter('bank_contact_phone')
batch = DocumentBatchDbObject.query.filter_by(
id=batch_id,
_owner=current_user,
deleted=False,
batch_type=DocumentBatchTypeEnum.DBT_NEW_LLC).scalar()
if not batch or not batch.data:
raise errors.BatchNotFound()
current_batch = DocumentBatch.db_obj_to_field(batch)
partner = BankPartnersObject.query.filter_by(id=bank_id).first()
if not partner:
raise errors.InvalidParameterValue('partner_id')
svc_data = BankPartnersServiceObject.query.filter_by(
bank_partner_id=partner.id).first()
if not svc_data:
raise errors.ServerError()
current_bank_request = BankPartnerRequestObject.query.filter_by(
bank_partner_id=partner.id, batch_id=batch_id).first()
if current_bank_request and current_bank_request.status in ('sending',
'success'):
struct = current_batch.get_api_structure()
return {'result': struct}
if current_bank_request and abs(
(datetime.utcnow() -
current_bank_request.sent_date).total_seconds()) > 60:
BankPartnerRequestObject.query.filter_by(
id=current_bank_request.id).delete()
sqldb.session.commit()
current_bank_request = None
svc_type = svc_data.type
fields = svc_data.fields
extra_context = {
'bank_contact_phone_general_manager':
bank_contact_phone_general_manager,
'bank_contact_phone': bank_contact_phone,
'send_private_data': send_private_data,
'bank_title': partner.title
}
field_list = BatchManager.make_fields_from_data(
batch_id, fields, current_app.config, extra_context=extra_context)
context = {}
errors_list = []
for name in field_list:
field = field_list[name]
try:
if not field.initialized:
if field.required:
raise MissingRequiredFieldException(name)
else:
field.validate()
except (InvalidFieldValueException, MissingRequiredFieldException), ex:
if hasattr(field, "suppress_validation_errors"):
suppress_validation_errors = field.suppress_validation_errors
if isinstance(suppress_validation_errors, dict):
suppress_validation_condition = Condition(
suppress_validation_errors)
context = copy.copy(batch.data)
context.update(extra_context)
suppress_validation_errors = suppress_validation_condition.check(
context)
if suppress_validation_errors:
continue
if getattr(ex, 'ext_data', None):
err_list = error_tree_to_list(ex.ext_data)
error_field_paths = [{
'field': name + '.' + i['field'],
'error_code': i['error_code']
} for i in err_list]
errors_list.extend(error_field_paths)
else:
errors_list.append({
'field': name,
'error_code': ex.ERROR_CODE
})
current_app.logger.exception(u"Field %s validation error" % name)
continue
if field_list[name].initialized:
context[name] = field_list[name]
def get_content_on_post(self, arguments=None, *args, **kwargs):
logger = self.application.logger # todo: ifns logger!
cache = self.application.cache
ifns = arguments['ifns']
service = arguments['service']
dt = arguments['datetime']
founder_applicant = arguments['founder_applicant']
batch_id = arguments['batch_id']
reg_responsible_person = arguments.get('reg_responsible_person', None)
service_nalog_ru_url = self.application.config['SERVICE_NALOG_RU_URL']
try:
company_data, person_data = yield AsyncIfnsProvider.get_company_person_data_for_ifns(
founder_applicant, self.user.email, self.application.db)
except Exception:
logger.exception(u"Failed to collect data")
raise errors.InvalidParameterValue("founder_applicant")
try:
reg_ifns = yield AsyncIfnsProvider.get_registration_ifns(
int_to_ifns(ifns),
cache,
service_nalog_ru_url=service_nalog_ru_url)
except Exception:
logger.exception(
u"Failed to get registration ifns. Address ifns: %s" %
unicode(ifns))
raise
reg_ifns_name = reg_ifns['rou']['naimk']
reg_ifns_addr = reg_ifns['adres']
try:
address = yield AsyncDadataProvider.get_detailed_address(
reg_ifns_addr, cache)
if not address:
raise Exception()
except Exception:
logger.exception(
u"Failed to get detailed address. Reg ifns address: %s" %
unicode(reg_ifns_addr))
raise
region_name = address['suggestions'][0]['data']['region']
# todo: remove booking tasks with the same batch_id:service. (remove objects (in statuses new & progress) & cancel tasks)
try:
result = yield AsyncIfnsProvider.book_ifns(
person_data, company_data, reg_ifns_name, service, region_name,
dt, reg_responsible_person, cache, logger)
except errors.IfnsServiceUnavailable, ex:
logger.exception(u"Failed to book ifns")
booking_obj = IfnsBookingObject(
**{
"batch_id": batch_id,
"person_data": person_data,
"company_data": company_data,
"reg_ifns_name": reg_ifns_name,
"service": service,
"region_name": region_name,
"reg_date": dt.strftime("%Y-%m-%dT%H:%M:%S"),
"reg_responsible_person": reg_responsible_person,
"status": IfnsBookingTaskStatus.BTS_NEW,
"error_info": None,
"user_email": self.user.email
})
sqldb.session.add(booking_obj)
sqldb.session.commit()
ifns_booking_task_id = booking_obj.id
ifns_booking_tasks.book_ifns(str(ifns_booking_task_id))
raise gen.Return({'error': True, 'error_type': "booking_queued"})
def update_profile(cls, auth_user, new_email, new_mobile=None):
temp_user = auth_user.temporal
if new_email:
new_email = new_email.lower()
if new_email and auth_user.email != new_email:
if AuthUser.query.filter_by(email=new_email).count():
raise errors.DuplicateEmail()
auth_user.email = new_email
auth_user.email_confirmed = False
if temp_user:
new_password = UserManager.generate_password()
password = unicode(encrypt_password(new_password))
link_code = cls._generate_link_code(True)
activation_link = UserActivationLink(
link_type=ConfirmationLinkTypeEnum.CLT_PASSWORD,
link_code=link_code,
auth_user=auth_user
)
db.session.add(activation_link)
from fw.async_tasks import send_email
schema = cls.__config['WEB_SCHEMA']
domain = cls.__config['DOMAIN']
selfcare_url = u"%s://%s/account/?" % (schema, domain)
selfcare_url = utm_args(selfcare_url, 'new_account_user_notify', auth_user.id)
selfcare_url = cls.make_auth_url(selfcare_url, auth_user).get_url(cls.__config)
tmpl_data = {
'password': new_password,
"link_code": activation_link.link_code,
'email': new_email,
"domain": domain,
"schema": schema,
"user_id": auth_user.uuid,
"selfcare_url": selfcare_url # {{'?'|utm_args('', user_id)}}
}
send_email.send_email.delay(new_email, "new_account_user_notify", **tmpl_data)
auth_user.password = password
auth_user.temporal = False
UserManager.confirm_new_email(auth_user, new_email, email_type="confirm_email")
db.session.commit()
elif new_email == u'':
# empty string: delete current email
raise errors.InvalidParameterValue('email')
if new_mobile and auth_user.mobile != new_mobile:
if AuthUser.query.filter_by(mobile=new_mobile).count():
raise errors.DuplicateMobile()
auth_user.mobile = new_mobile
auth_user.mobile_confirmed = False
UserManager.confirm_new_mobile(auth_user, new_mobile)
db.session.commit()
elif new_mobile == u"":
auth_user.mobile = None
auth_user.mobile_confirmed = False
db.session.commit()
return auth_user
