class rbVisitType(db.Model):
__tablename__ = u'rbVisitType'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.Unicode(8), nullable=False, index=True)
name = db.Column(db.Unicode(64), nullable=False, index=True)
serviceModifier = db.Column(db.Unicode(128), nullable=False)
class ConfigVariables(db.Model):
__tablename__ = '%s_config' % TABLE_PREFIX
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(25), unique=True, nullable=False)
name = db.Column(db.Unicode(50), unique=True, nullable=False)
value = db.Column(db.Unicode(100))
value_type = db.Column(db.String(30))
def __unicode__(self):
return self.code
class Street(db.Model):
__bind_key__ = 'kladr'
__tablename__ = 'STREET'
__table_args__ = (db.Index('NAME_SOCR', 'NAME', 'SOCR', 'CODE'), )
NAME = db.Column(db.Unicode(40), nullable=False)
SOCR = db.Column(db.Unicode(10), nullable=False)
CODE = db.Column(db.String(17), primary_key=True)
INDEX = db.Column(db.String(6), nullable=False)
GNINMB = db.Column(db.String(4), nullable=False)
UNO = db.Column(db.String(4), nullable=False)
OCATD = db.Column(db.String(11), nullable=False)
infis = db.Column(db.String(5), nullable=False, index=True)
class rbUnit(db.Model):
__tablename__ = u'rbUnit'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.Unicode(256), index=True)
name = db.Column(db.Unicode(256), index=True)
def __json__(self):
return {
'id': self.id,
'code': self.code,
'name': self.name,
}
class rbAppointmentType(db.Model):
__tablename__ = 'rbAppointmentType'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.Unicode(32), nullable=False)
name = db.Column(db.Unicode(64), nullable=False)
def __unicode__(self):
return u'(%s) %s' % (self.code, self.name)
def __json__(self):
return {
'code': self.code,
'name': self.name,
}
class ClientContact(db.Model):
__tablename__ = 'ClientContact'
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
client_id = db.Column(db.ForeignKey('Client.id'),
nullable=False,
index=True)
contactType_id = db.Column(db.Integer,
db.ForeignKey('rbContactType.id'),
nullable=False,
index=True)
contact = db.Column(db.String(32), nullable=False)
notes = db.Column(db.Unicode(64), nullable=False, default=u'')
version = db.Column(db.Integer, nullable=False, default=0)
contactType = db.relationship(u'rbContactType', lazy=False)
def __init__(self, cont_type, text, notes, client):
self.contactType_id = int(cont_type) if cont_type else None
self.contact = text
self.notes = notes
self.client = client
@property
def name(self):
return self.contactType.name if self.contactType else None
def __json__(self):
return {
'id': self.id,
'deleted': self.deleted,
'contact_type': self.contactType,
'contact_text': self.contact,
'notes': self.notes
}
def __int__(self):
return self.id
class rbJobType(db.Model):
__tablename__ = u'rbJobType'
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, index=True)
code = db.Column(db.String(64), nullable=False)
regionalCode = db.Column(db.String(64), nullable=False)
name = db.Column(db.Unicode(128), nullable=False)
laboratory_id = db.Column(db.Integer, index=True)
isInstant = db.Column(db.Integer, nullable=False, server_default=u"'0'")
class Kladr(db.Model):
__bind_key__ = 'kladr'
__tablename__ = 'KLADR'
__table_args__ = (db.Index('long_name', 'prefix', 'NAME', 'SOCR',
'STATUS'), db.Index('NAME', 'NAME', 'SOCR'),
db.Index('parent', 'parent', 'NAME', 'SOCR', 'CODE'))
NAME = db.Column(db.Unicode(40), nullable=False)
SOCR = db.Column(db.Unicode(10), nullable=False)
CODE = db.Column(db.String(13), primary_key=True)
INDEX = db.Column(db.String(6), nullable=False)
GNINMB = db.Column(db.String(4), nullable=False)
UNO = db.Column(db.String(4), nullable=False)
OCATD = db.Column(db.String(11), nullable=False, index=True)
STATUS = db.Column(db.String(1), nullable=False)
parent = db.Column(db.String(13), nullable=False)
infis = db.Column(db.String(5), nullable=False, index=True)
prefix = db.Column(db.String(2), nullable=False)
id = db.Column(db.Integer, nullable=False, unique=True)
class ClientIntoleranceMedicament(db.Model):
__tablename__ = u'ClientIntoleranceMedicament'
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
client_id = db.Column(db.ForeignKey('Client.id'),
nullable=False,
index=True)
name = db.Column("nameMedicament", db.Unicode(128), nullable=False)
power = db.Column(db.Integer, nullable=False)
createDate = db.Column(db.Date)
notes = db.Column(db.String, nullable=False, default='')
version = db.Column(db.Integer, nullable=False, default=0)
def __init__(self, name, power, date, notes, client):
self.name = name
self.power = power
self.createDate = date
self.notes = notes
self.client = client
def __json__(self):
return {
'id': self.id,
'deleted': self.deleted,
'name': self.name,
'power':
AllergyPower(self.power) if self.power is not None else None,
'date': self.createDate,
'notes': self.notes
}
def __unicode__(self):
return self.name
def __int__(self):
return self.id
class Office(db.Model):
__tablename__ = 'Office'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.Unicode(32), nullable=False)
name = db.Column(db.Unicode(64), nullable=False)
orgStructure_id = db.Column(db.ForeignKey('OrgStructure.id'))
orgStructure = db.relationship('OrgStructure')
def __unicode__(self):
return self.code
def __json__(self):
return {
'id': self.id,
'code': self.code,
'name': self.name,
'org_structure': self.orgStructure
}
class rbHospitalBedType(db.Model):
__tablename__ = u'rbHospitalBedType'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(8), nullable=False, index=True)
name = db.Column(db.Unicode(64), nullable=False, index=True)
def __json__(self):
return {
'id': self.id,
'code': self.code,
'name': self.name,
}
class ScheduleClientTicket(db.Model):
__tablename__ = 'ScheduleClientTicket'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
client_id = db.Column(db.Integer, db.ForeignKey('Client.id'), nullable=False)
ticket_id = db.Column(db.Integer, db.ForeignKey('ScheduleTicket.id'), nullable=False)
isUrgent = db.Column(db.Boolean)
note = db.Column(db.Unicode(256), default=u'')
appointmentType_id = db.Column(db.Integer, db.ForeignKey('rbAppointmentType.id'))
infisFrom = db.Column(db.Unicode(20))
createDatetime = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer, db.ForeignKey('Person.id'), index=True, default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer, db.ForeignKey('Person.id'), index=True, default=safe_current_user_id, onupdate=safe_current_user_id)
deleted = db.Column(db.SmallInteger, nullable=False, server_default='0', default=0)
event_id = db.Column(db.ForeignKey('Event.id'))
client = db.relationship('Client', lazy='joined', uselist=False)
appointmentType = db.relationship('rbAppointmentType', lazy=False, innerjoin=True)
createPerson = db.relationship('Person', foreign_keys=[createPerson_id])
event = db.relationship('Event')
ticket = db.relationship(
'ScheduleTicket', lazy=True, innerjoin=True, uselist=False,
primaryjoin='and_('
'ScheduleClientTicket.deleted == 0, '
'ScheduleTicket.deleted == 0, '
'ScheduleClientTicket.ticket_id == ScheduleTicket.id)'
)
@property
def org_from(self):
if not self.infisFrom:
return
from .exists import Organisation
org = Organisation.query.filter(Organisation.infisCode == self.infisFrom).first()
if not org:
return self.infisFrom
return org.title
class rbHospitalBedProfile(db.Model):
__tablename__ = u'rbHospitalBedProfile'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(8), nullable=False, index=True)
name = db.Column(db.Unicode(64), nullable=False, index=True)
service_id = db.Column(db.Integer,
db.ForeignKey('rbService.id'),
index=True)
# service = db.relationship('rbService')
def __json__(self):
return {
'id': self.id,
'code': self.code,
'name': self.name,
}
class ClientPolicy(db.Model):
__tablename__ = 'ClientPolicy'
__table_args__ = (db.Index(u'Serial_Num', u'serial', u'number'),
db.Index(u'client_insurer', u'client_id', u'insurer_id'))
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
clientId = db.Column("client_id",
db.ForeignKey('Client.id'),
nullable=False)
insurer_id = db.Column(db.Integer,
db.ForeignKey('Organisation.id'),
index=True)
policyType_id = db.Column(db.Integer,
db.ForeignKey('rbPolicyType.id'),
index=True)
serial = db.Column(db.String(16), nullable=False)
number = db.Column(db.String(16), nullable=False)
begDate = db.Column(db.Date, nullable=False)
endDate = db.Column(db.Date)
name = db.Column(db.Unicode(64),
nullable=False,
server_default=u"''",
default=u'')
note = db.Column(db.Unicode(200),
nullable=False,
server_default=u"''",
default=u'')
version = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
insurer = db.relationship(u'Organisation', lazy=False)
policyType = db.relationship(u'rbPolicyType', lazy=False)
def __init__(self, pol_type, serial, number, beg_date, end_date, insurer,
client):
self.policyType_id = int(pol_type) if pol_type else None
self.serial = serial
self.number = number
self.begDate = beg_date
self.endDate = end_date
self.insurer_id = int(insurer['id']) if insurer['id'] else None
self.name = insurer['full_name'] if not insurer['id'] else None
self.client = client
def __unicode__(self):
return (' '.join([
self.policyType.name,
unicode(self.insurer) if self.insurer else '', self.serial,
self.number
])).strip()
def __int__(self):
return self.id
def __json__(self):
return {
'id': self.id,
'policy_type': self.policyType,
'deleted': self.deleted,
'serial': self.serial,
'number': self.number,
'beg_date': self.begDate,
'end_date': self.endDate,
'insurer': self.insurer if self.insurer else {
'id': None,
'full_name': self.name,
'short_name': self.name,
'infis': None,
'title': None
},
'policy_text': self.__unicode__()
}
class Client(db.Model):
__tablename__ = 'Client'
__table_args__ = (db.Index(u'lastName', u'lastName', u'firstName',
u'patrName', u'birthDate', u'id'), )
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
lastName = db.Column(db.Unicode(30), nullable=False)
firstName = db.Column(db.Unicode(30), nullable=False)
patrName = db.Column(db.Unicode(30), nullable=False)
birthDate = db.Column(db.Date, nullable=False, index=True)
sexCode = db.Column("sex", db.Integer, nullable=False)
SNILS = db.Column(db.String(11), nullable=False, index=True)
bloodType_id = db.Column(db.ForeignKey('rbBloodType.id'), index=True)
bloodDate = db.Column(db.Date)
bloodNotes = db.Column(db.String, nullable=False, default='')
growth = db.Column(db.String(16), nullable=False, default='0')
weight = db.Column(db.String(16), nullable=False, default='0')
notes = db.Column(db.String, nullable=False, default='')
version = db.Column(db.Integer, nullable=False, default=0)
birthPlace = db.Column(db.String(128),
nullable=False,
server_default=u"''")
embryonalPeriodWeek = db.Column(db.String(16),
nullable=False,
server_default=u"''")
uuid_id = db.Column(db.ForeignKey('UUID.id'),
nullable=False,
index=True,
server_default=u"'0'")
uuid = db.relationship('UUID')
documents = db.relationship(
u'ClientDocument',
primaryjoin=
'and_(ClientDocument.clientId==Client.id, ClientDocument.deleted == 0)',
order_by="desc(ClientDocument.id)",
backref=db.backref('client'),
lazy='dynamic')
documents_all = db.relationship(
'ClientDocument',
primaryjoin=
'and_(ClientDocument.clientId==Client.id, ClientDocument.deleted != 1)',
order_by="desc(ClientDocument.id)")
policies = db.relationship(
u'ClientPolicy',
primaryjoin=
'and_(ClientPolicy.clientId==Client.id, ClientPolicy.deleted == 0)',
order_by="desc(ClientPolicy.id)",
backref=db.backref('client'),
lazy='dynamic')
policies_all = db.relationship(
'ClientPolicy',
primaryjoin=
'and_(ClientPolicy.clientId==Client.id, ClientPolicy.deleted != 1)',
order_by="desc(ClientPolicy.id)")
addresses = db.relationship(
'ClientAddress',
primaryjoin=
"and_(Client.id==ClientAddress.client_id, ClientAddress.deleted==0)",
backref=db.backref('client'))
reg_address = db.relationship(
u'ClientAddress',
primaryjoin=
"and_(Client.id==ClientAddress.client_id, ClientAddress.type==0, ClientAddress.deleted==0)",
order_by="desc(ClientAddress.id)",
uselist=False)
loc_address = db.relationship(
u'ClientAddress',
primaryjoin=
"and_(Client.id==ClientAddress.client_id, ClientAddress.type==1, ClientAddress.deleted==0)",
order_by="desc(ClientAddress.id)",
uselist=False)
soc_statuses = db.relationship(
u'ClientSocStatus',
primaryjoin=
'and_(ClientSocStatus.deleted == 0, ClientSocStatus.client_id==Client.id)',
backref=db.backref('client'))
intolerances = db.relationship(
u'ClientIntoleranceMedicament',
primaryjoin=
'and_(ClientIntoleranceMedicament.client_id==Client.id, ClientIntoleranceMedicament.deleted == 0)',
backref=db.backref('client'),
lazy='dynamic')
identifications = db.relationship(
u'ClientIdentification',
primaryjoin=
'and_(ClientIdentification.client_id==Client.id, ClientIdentification.deleted == 0)',
backref=db.backref('client'),
lazy='dynamic')
allergies = db.relationship(
u'ClientAllergy',
primaryjoin=
'and_(ClientAllergy.client_id==Client.id, ClientAllergy.deleted == 0)',
backref=db.backref('client'),
lazy='dynamic')
blood_history = db.relationship(u'BloodHistory',
backref=db.backref('client'),
order_by='desc(BloodHistory.id)',
lazy='dynamic')
client_relations = db.relationship(
u'ClientRelation',
primaryjoin=
'and_(ClientRelation.deleted == 0, or_(ClientRelation.client_id == Client.id, ClientRelation.relative_id == Client.id)) ',
lazy='dynamic')
contacts = db.relationship(
'ClientContact',
primaryjoin=
'and_(ClientContact.client_id==Client.id, ClientContact.deleted == 0)',
backref=db.backref('client'),
lazy='dynamic')
works = db.relationship(
u'ClientWork',
primaryjoin=
'and_(ClientWork.client_id==Client.id, ClientWork.deleted == 0)',
order_by="desc(ClientWork.id)")
events = db.relationship(
u'Event',
lazy='dynamic',
order_by='desc(Event.createDatetime)',
primaryjoin='and_(Event.deleted == 0, Event.client_id == Client.id)')
appointments = db.relationship(
u'ScheduleClientTicket',
lazy='dynamic', #order_by='desc(ScheduleTicket.begDateTime)',
primaryjoin='and_('
'ScheduleClientTicket.deleted == 0, '
'ScheduleClientTicket.client_id == Client.id)',
innerjoin=True)
def __init__(self):
self.init_on_load()
@orm.reconstructor
def init_on_load(self):
# TODO: redo?
self._id_document = None
def age_tuple(self, moment=None):
"""
@type moment: datetime.datetime
"""
if not self.birthDate:
return None
if not moment:
moment = datetime.date.today()
return calcAgeTuple(self.birthDate, moment)
@property
def age(self):
bd = self.birthDate
date = datetime.date.today()
if not self.age_tuple():
return u'ещё не родился'
(days, weeks, months, years) = self.age_tuple()
if years > 7:
return formatYears(years)
elif years > 1:
return formatYearsMonths(years, months - 12 * years)
elif months > 1:
add_year, new_month = divmod(bd.month + months, 12)
if new_month:
new_day = min(
bd.day,
calendar.monthrange(bd.year + add_year, new_month)[1])
fmonth_date = datetime.date(bd.year + add_year, new_month,
new_day)
else:
fmonth_date = bd
return formatMonthsWeeks(months, (date - fmonth_date).days / 7)
else:
return formatDays(days)
@property
def nameText(self):
return u' '.join((u'%s %s %s' % (self.lastName or '', self.firstName
or '', self.patrName or '')).split())
@property
def shortNameText(self):
words = self.firstName.split() + self.patrName.split()
initials = ['%s.' % word[0].upper() for word in words if word]
return u'%s %s' % (self.lastName, u' '.join(initials))
@property
def sex(self):
return unicode(Gender(self.sexCode))
@property
def formatted_SNILS(self):
if self.SNILS:
s = self.SNILS + ' ' * 14
return u'%s-%s-%s %s' % (s[0:3], s[3:6], s[6:9], s[9:11])
else:
return u''
@property
def document(self):
return self.id_document
@property
def id_document(self):
if not self._id_document:
self._id_document = (
self.documents.join(rbDocumentType).join(rbDocumentTypeGroup).
filter(ClientDocument.deleted == 0).filter(
rbDocumentTypeGroup.code == ID_DOC_GROUP_CODE).order_by(
ClientDocument.date.desc()).first())
return self._id_document
def get_actual_document_by_code(self, doc_type_code):
# пока не используется
return (self.documents.filter(ClientDocument.deleted == 0).filter(
rbDocumentTypeGroup.code == doc_type_code).order_by(
ClientDocument.date.desc()).first())
@property
def actual_soc_statuses(self):
return filter(
lambda s: not s.endDate or s.endDate >= datetime.date.today(),
self.soc_statuses)
@property
def policy(self):
return self.compulsoryPolicy
@property
def policyDMS(self):
return self.voluntaryPolicies
@property
def compulsoryPolicy(self):
cpols = filter(
lambda p: p.policyType is not None and p.policyType.code in
COMP_POLICY_CODES, self.policies)
return cpols[0] if cpols else None
@property
def voluntaryPolicies(self):
return filter(
lambda p: p.policyType is not None and p.policyType.code in
VOL_POLICY_CODES, self.policies)
@property
def phones(self):
return [
(u'%s: %s (%s)' % (contact.name, contact.contact, contact.notes))
if contact.notes else (u'%s: %s' % (contact.name, contact.contact))
for contact in self.contacts.join(rbContactType).order_by(
rbContactType.idx)
]
def has_identical_addresses(self):
reg = self.reg_address
live = self.loc_address
if reg and live:
if reg.address and live.address:
return reg.address.id == live.address.id
else:
return reg.freeInput == live.freeInput
return False
def __unicode__(self):
return self.nameText
def __int__(self):
return self.id
def __json__(self):
return {
'id': self.id,
'first_name': self.firstName,
'last_name': self.lastName,
'patr_name': self.patrName,
'birth_date': self.birthDate,
'sex': Gender(self.sexCode) if self.sexCode is not None else None,
'snils': self.SNILS,
'full_name': self.nameText,
'notes': self.notes,
'age_tuple': self.age_tuple(),
'age': self.age,
'sex_raw': self.sexCode
}
class ClientSocStatus(db.Model):
__tablename__ = u'ClientSocStatus'
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
client_id = db.Column(db.ForeignKey('Client.id'),
nullable=False,
index=True)
socStatusClass_id = db.Column(db.ForeignKey('rbSocStatusClass.id'),
index=True)
socStatusType_id = db.Column(db.ForeignKey('rbSocStatusType.id'),
nullable=False,
index=True)
begDate = db.Column(db.Date, nullable=False)
endDate = db.Column(db.Date)
document_id = db.Column(db.ForeignKey('ClientDocument.id'), index=True)
note = db.Column(db.Unicode(200),
nullable=False,
server_default=u"''",
default=u'')
version = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
benefitCategory_id = db.Column(db.Integer)
soc_status_class = db.relationship(u'rbSocStatusClass', lazy=False)
socStatusType = db.relationship(u'rbSocStatusType', lazy=False)
self_document = db.relationship(u'ClientDocument', lazy=False)
@property
def classes(self):
return self.socStatusType.classes
@property
def code(self):
return self.socStatusType.code
@property
def name(self):
return self.socStatusType.name
@property
def document(self):
if self.document_id:
return self.self_document
else:
return self.getClientDocument()
def __init__(self, soc_stat_class, soc_stat_type, beg_date, end_date,
client, document):
self.socStatusClass_id = int(
soc_stat_class) if soc_stat_class else None
self.socStatusType_id = int(soc_stat_type) if soc_stat_type else None
self.begDate = beg_date
self.self_document = document
self.endDate = end_date
self.client = client
def getClientDocument(self):
documents = ClientDocument.query().filter(ClientDocument.clientId == self.client_id).\
filter(ClientDocument.deleted == 0).all()
documents = [
document for document in documents if document.documentType
and document.documentType.group.code == "1"
]
return documents[-1]
def __unicode__(self):
return self.name
def __int__(self):
return self.id
def __json__(self):
return {
'id': self.id,
'ss_type': self.socStatusType,
'ss_class': self.soc_status_class,
'deleted': self.deleted,
'beg_date': self.begDate,
'end_date': self.endDate,
'self_document': self.self_document
}
class EventLocalContract(db.Model):
__tablename__ = u'Event_LocalContract'
__table_args__ = (db.Index(u'lastName', u'lastName', u'firstName',
u'patrName', u'birthDate', u'id'), )
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
createPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id)
modifyDatetime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
modifyPerson_id = db.Column(db.Integer,
index=True,
default=safe_current_user_id,
onupdate=safe_current_user_id)
deleted = db.Column(db.Integer,
nullable=False,
server_default=u"'0'",
default=0)
master_id = db.Column(db.Integer)
coordDate = db.Column(db.DateTime)
coordAgent = db.Column(db.String(128),
nullable=False,
server_default=u"''")
coordInspector = db.Column(db.String(128),
nullable=False,
server_default=u"''")
coordText = db.Column(db.String, nullable=False)
dateContract = db.Column(db.Date, nullable=False)
numberContract = db.Column(db.Unicode(64), nullable=False)
sumLimit = db.Column(db.Float(asdecimal=True), nullable=False)
lastName = db.Column(db.Unicode(30), nullable=False)
firstName = db.Column(db.Unicode(30), nullable=False)
patrName = db.Column(db.Unicode(30), nullable=False)
birthDate = db.Column(db.Date, nullable=False, index=True)
documentType_id = db.Column(db.Integer,
db.ForeignKey('rbDocumentType.id'),
index=True)
serialLeft = db.Column(db.Unicode(8), nullable=False)
serialRight = db.Column(db.Unicode(8), nullable=False)
number = db.Column(db.String(16), nullable=False)
regAddress = db.Column(db.Unicode(64), nullable=False)
org_id = db.Column(db.Integer,
db.ForeignKey('Organisation.id'),
index=True)
org = db.relationship(u'Organisation')
documentType = db.relationship(u'rbDocumentType')
# payments = db.relationship('EventPayment', backref=db.backref('local_contract'))
# Это что вообще?!
@property
def document(self):
document = ClientDocument()
document.documentType = self.documentType
document.serial = u'%s %s' % (self.serialLeft, self.serialRight)
document.number = self.number
return document
def __unicode__(self):
parts = []
if self.coordDate:
parts.append(u'согласовано ' + self.coordDate)
if self.coordText:
parts.append(self.coordText)
if self.number:
parts.append(u'№ ' + self.number)
if self.date:
parts.append(u'от ' + self.date)
if self.org:
parts.append(unicode(self.org))
else:
parts.append(self.lastName)
parts.append(self.firstName)
parts.append(self.patrName)
return ' '.join(parts)
def __json__(self):
return {
'id': self.id,
'number_contract': self.numberContract,
'date_contract': self.dateContract,
'first_name': self.firstName,
'last_name': self.lastName,
'patr_name': self.patrName,
'birth_date': self.birthDate,
'doc_type_id': self.documentType_id,
'doc_type': self.documentType,
'serial_left': self.serialLeft,
'serial_right': self.serialRight,
'number': self.number,
'reg_address': self.regAddress,
'payer_org_id': self.org_id,
'payer_org': self.org,
}
def __int__(self):
return self.id
class ActionType(db.Model):
__tablename__ = u'ActionType'
id = db.Column(db.Integer, primary_key=True)
createDatetime = db.Column(db.DateTime, nullable=False)
createPerson_id = db.Column(db.Integer, index=True)
modifyDatetime = db.Column(db.DateTime, nullable=False)
modifyPerson_id = db.Column(db.Integer, index=True)
deleted = db.Column(db.Integer, nullable=False, server_default=u"'0'")
hidden = db.Column(db.Integer, nullable=False, server_default=u"'0'")
class_ = db.Column(u'class', db.Integer, nullable=False, index=True)
group_id = db.Column(db.Integer,
db.ForeignKey('ActionType.id'),
index=True)
code = db.Column(db.String(25), nullable=False)
name = db.Column(db.Unicode(255), nullable=False)
title = db.Column(db.Unicode(255), nullable=False)
flatCode = db.Column(db.String(64), nullable=False, index=True)
sex = db.Column(db.Integer, nullable=False)
age = db.Column(db.String(9), nullable=False)
age_bu = db.Column(db.Integer)
age_bc = db.Column(db.SmallInteger)
age_eu = db.Column(db.Integer)
age_ec = db.Column(db.SmallInteger)
office = db.Column(db.String(32), nullable=False)
showInForm = db.Column(db.Integer, nullable=False)
genTimetable = db.Column(db.Integer, nullable=False)
service_id = db.Column(db.Integer,
db.ForeignKey('rbService.id'),
index=True)
quotaType_id = db.Column(db.Integer, index=True)
context = db.Column(db.String(64), nullable=False)
amount = db.Column(db.Float(asdecimal=True),
nullable=False,
server_default=u"'1'")
amountEvaluation = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
defaultStatus = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
defaultDirectionDate = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
defaultPlannedEndDate = db.Column(db.Integer, nullable=False)
defaultEndDate = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
defaultExecPerson_id = db.Column(db.Integer, index=True)
defaultPersonInEvent = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
defaultPersonInEditor = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
maxOccursInEvent = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
showTime = db.Column(db.Integer, nullable=False, server_default=u"'0'")
isMES = db.Column(db.Integer)
nomenclativeService_id = db.Column(db.Integer,
db.ForeignKey('rbService.id'),
index=True)
isPreferable = db.Column(db.Integer, nullable=False, server_default=u"'1'")
prescribedType_id = db.Column(db.Integer, index=True)
shedule_id = db.Column(db.Integer, index=True)
isRequiredCoordination = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
isRequiredTissue = db.Column(db.Integer,
nullable=False,
server_default=u"'0'")
testTubeType_id = db.Column(db.Integer, index=True)
jobType_id = db.Column(db.ForeignKey('rbJobType.id'), index=True)
mnem = db.Column(db.String(32), server_default=u"''")
layout = db.Column(db.Text)
service = db.relationship(u'rbService',
foreign_keys='ActionType.service_id')
nomenclatureService = db.relationship(
u'rbService', foreign_keys='ActionType.nomenclativeService_id')
property_types = db.relationship(u'ActionPropertyType', lazy='dynamic')
group = db.relationship(u'ActionType', remote_side=[id])
jobType = db.relationship(u'rbJobType', lazy=False)
tissue_type = db.relationship(
'ActionType_TissueType',
primaryjoin=
'and_(ActionType_TissueType.master_id == ActionType.id, ActionType_TissueType.idx == 0)',
uselist=False)
def get_property_type_by_name(self, name):
return self.property_types.filter(
ActionPropertyType.name == name).first()
def get_property_type_by_code(self, code):
return self.property_types.filter(
ActionPropertyType.code == code).first()
def __json__(self):
return {
'id': self.id,
'code': self.code,
'name': self.name,
'class': self.class_,
'flat_code': self.flatCode,
'title': self.title,
'context_name': self.context,
}
