def get_form(self, schema):
# counter is used to avoid field name conflicts
form = Form(schema, counter=itertools.count(15000), method='GET')
if self.grid is not None:
form.formid = 'grid_search_form'
form.widget = deform_extensions.GridFormWidget(
named_grid=self.grid)
form.buttons = (deform.Button(title='Filtrer',
name='submit',
type='submit',
css_class='btn btn-primary'), )
else:
form.widget.template = "autonomie:deform_templates/searchform.pt"
return form
def set_form_widget(self, form):
"""
Attach a custom widget to the given form
:param obj form: The deform.Form instance
:returns: The deform.Form instance
:rtype: obj
"""
if self.grid is not None:
form.formid = 'grid_search_form'
form.widget = deform_extensions.GridFormWidget(
named_grid=self.grid)
else:
form.widget.template = "searchform.pt"
return form
class Tva(DBBASE):
"""
`id` int(2) NOT NULL auto_increment,
`name` varchar(8) NOT NULL,
`value` int(5)
`default` int(2) default 0 #rajouté par mise à jour 1.2
"""
__colanderalchemy_config__ = {
"title": u"un taux de TVA",
"validation_msg": u"Les taux de Tva ont bien été configurés",
"help_msg": u"""Configurez les taux de Tva disponibles utilisés dans \
Autonomie, ainsi que les produits associés.<br /> \
Une Tva est composée :<ul><li>D'un libellé (ex : TVA 20%)</li> \
<li>D'un montant (ex : 20)</li> \
<li>D'un ensemble d'informations comptables</li> \
<li>D'un ensemble de produits associés</li> \
<li> D'une mention : si elle est renseignée, celle-ci viendra se placer
en lieu et place du libellé (ex : Tva non applicable en vertu ...)
</ul><br /> \
<b>Note : les montants doivent tous être distincts, si vous utilisez \
plusieurs Tva à 0%, utilisez des montants négatifs pour les \
différencier. \
""",
'widget': deform_extensions.GridFormWidget(named_grid=TVA_GRID)
}
__tablename__ = 'tva'
__table_args__ = default_table_args
id = Column(
'id',
Integer,
primary_key=True,
info={'colanderalchemy': {
'widget': deform.widget.HiddenWidget()
}},
)
active = Column(
Boolean(),
default=True,
info={'colanderalchemy': {
'exclude': True
}},
)
name = Column(
"name",
String(15),
nullable=False,
info={'colanderalchemy': {
'title': u'Libellé du taux de TVA',
}},
)
value = Column(
"value",
Integer,
info={
"colanderalchemy": {
'title': u'Valeur',
'typ': AmountType(),
'description': u"Le pourcentage associé (ex : 19.6)",
}
},
)
compte_cg = Column(
"compte_cg",
String(125),
default="",
info={'colanderalchemy': dict(title=u"Compte CG de Tva")})
code = Column("code",
String(125),
default="",
info={'colanderalchemy': dict(title=u"Code de Tva")})
compte_a_payer = Column(
String(125),
default='',
info={
'colanderalchemy':
dict(
title=u"Compte de Tva à payer",
description=u"Utilisé dans les exports comptables des \
encaissements",
)
})
mention = Column(Text,
info={
'colanderalchemy': {
'title': u"Mentions spécifiques à cette TVA",
'description':
u"""Si cette Tva est utilisée dans un
devis/une facture,la mention apparaitra dans la sortie PDF
(ex: Mention pour la tva liée aux formations ...)""",
'widget': deform.widget.TextAreaWidget(rows=1),
'preparer': clean_html,
'missing': colander.drop,
}
})
default = Column(
"default",
Boolean(),
info={
"colanderalchemy": {
'title': u'Cette tva doit-elle être proposée par défaut ?'
}
},
)
products = relationship(
"Product",
cascade="all, delete-orphan",
info={
'colanderalchemy': {
'title':
u"Comptes produit associés",
"widget":
deform.widget.SequenceWidget(
add_subitem_text_template=u"Ajouter un compte produit", )
},
},
back_populates='tva',
)
@classmethod
def query(cls, include_inactive=False):
q = super(Tva, cls).query()
if not include_inactive:
q = q.filter(Tva.active == True)
return q.order_by('value')
@classmethod
def by_value(cls, value):
"""
Returns the Tva matching this value
"""
return super(Tva, cls).query().filter(cls.value == value).one()
@classmethod
def get_default(cls):
return cls.query().filter_by(default=True).first()
def __json__(self, request):
return dict(
id=self.id,
value=integer_to_amount(self.value, 2),
label=self.name,
name=self.name,
default=self.default,
products=[product.__json__(request) for product in self.products],
)
@classmethod
def unique_value(cls, value, tva_id=None):
"""
Check that the given value has not already been attributed to a tva
entry
:param int value: The value currently configured
:param int tva_id: The optionnal id of the current tva object (edition
mode)
:returns: True/False
:rtype: bool
"""
query = cls.query(include_inactive=True)
if tva_id:
query = query.filter(not_(cls.id == tva_id))
return query.filter_by(value=value).count() == 0
class CareerPath(DBBASE):
"""
Different career path stages
"""
__colanderalchemy_config__ = {
'title': u"Etape de parcours",
'help_msg': u"",
'validation_msg': u"L'étape de parcours a bien été enregistrée",
'widget': deform_extensions.GridFormWidget(named_grid=CAREER_PATH_GRID)
}
__tablename__ = 'career_path'
__table_args__ = default_table_args
id = Column(
'id',
Integer,
primary_key=True,
info={'colanderalchemy': {
'widget': deform.widget.HiddenWidget()
}},
)
userdatas_id = Column(
ForeignKey('user_datas.id'),
info={
'colanderalchemy': {
'exclude': True
},
'export': {
'label': u"Identifiant Autonomie",
'stats': {
'exclude': True
},
}
},
)
userdatas = relationship('UserDatas',
info={
'colanderalchemy': {
'exclude': True
},
'export': {
'exclude': True
},
})
start_date = Column(Date(),
nullable=False,
info={'colanderalchemy': {
'title': u"Date d'effet"
}})
end_date = Column(Date(),
info={'colanderalchemy': {
'title': u"Date d'échéance"
}})
career_stage_id = Column(
ForeignKey('career_stage.id'),
info={'colanderalchemy': {
'title': u"Type d'étape"
}})
career_stage = relationship(
'CareerStage',
primaryjoin='CareerStage.id==CareerPath.career_stage_id',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u'Etape de parcours'),
'export': {
'related_key': 'label'
},
},
)
cae_situation_id = Column(
ForeignKey('cae_situation_option.id'),
info={
'colanderalchemy': {
'title':
u"Nouvelle situation dans la CAE",
'description':
u"Lorsque cette étape sera affectée à un \
porteur cette nouvelle situation sera proposée par défaut"
}
})
cae_situation = relationship(
'CaeSituationOption',
primaryjoin='CaeSituationOption.id==CareerPath.cae_situation_id',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u'Situation dans la CAE'),
'export': {
'related_key': 'label'
},
},
)
stage_type = Column(String(15),
info={
'colanderalchemy': {
'title': u"Type d'étape"
},
'export': {
'formatter':
lambda val: dict(STAGE_TYPE_OPTIONS).get(val),
'stats': {
'options': STAGE_TYPE_OPTIONS
},
}
})
type_contrat_id = Column(
ForeignKey('type_contrat_option.id'),
info={'colanderalchemy': {
'title': u"Type de contrat"
}})
type_contrat = relationship(
'TypeContratOption',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u'Type de contrat'),
'export': {
'related_key': 'label'
},
},
)
employee_quality_id = Column(
ForeignKey('employee_quality_option.id'),
info={'colanderalchemy': {
'title': u"Qualité du salarié"
}})
employee_quality = relationship(
'EmployeeQualityOption',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u"Qualité du salarié"),
'export': {
'related_key': 'label'
},
})
taux_horaire = Column(Float(),
info={'colanderalchemy': {
'title': u"Taux horaire"
}})
num_hours = Column(Float(),
info={'colanderalchemy': {
'title': u"Nombre d'heures"
}})
goals_amount = Column(
Float(),
info={'colanderalchemy': {
'title': u"Objectif de CA / d'activité"
}})
goals_period = Column(String(15),
info={
'colanderalchemy': {
'title': u"Période de l'objectif"
},
'export': {
'formatter':
lambda val: dict(PERIOD_OPTIONS).get(val),
'stats': {
'options': PERIOD_OPTIONS
},
}
})
amendment_number = Column(
Integer(), info={'colanderalchemy': {
'title': u"Numéro de l'avenant"
}})
type_sortie_id = Column(
ForeignKey('type_sortie_option.id'),
info={'colanderalchemy': {
'title': u"Type de sortie"
}})
type_sortie = relationship(
'TypeSortieOption',
info={
'colanderalchemy': get_excluded_colanderalchemy(u"Type de sortie"),
'export': {
'related_key': 'label'
},
},
)
motif_sortie_id = Column(
ForeignKey('motif_sortie_option.id'),
info={'colanderalchemy': {
'title': u"Motif de sortie"
}})
motif_sortie = relationship(
'MotifSortieOption',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u"Motif de sortie"),
'export': {
'related_key': 'label'
},
},
)
@classmethod
def query(cls, user):
q = super(CareerPath, cls).query()
q = q.filter(CareerPath.userdatas_id == user)
return q.order_by(CareerPath.start_date.desc())
class CareerStage(DBBASE):
"""
Different career stages
"""
__colanderalchemy_config__ = {
'validation_msg': u"Les étapes de parcours ont bien été configurées",
'widget':
deform_extensions.GridFormWidget(named_grid=CAREER_STAGE_GRID)
}
__tablename__ = 'career_stage'
__table_args__ = default_table_args
id = Column(
'id',
Integer,
primary_key=True,
info={'colanderalchemy': {
'widget': deform.widget.HiddenWidget()
}},
)
active = Column(
Boolean(),
default=True,
info={'colanderalchemy': {
'exclude': True
}},
)
name = Column(
"name",
String(100),
nullable=False,
info={'colanderalchemy': {
'title': u"Libellé de l'étape"
}},
)
cae_situation_id = Column(
ForeignKey("cae_situation_option.id"),
info={
'colanderalchemy': {
'title':
u"Nouvelle situation dans la CAE",
'description':
u"Lorsque cette étape sera affectée à un \
porteur de projet cette situation lui sera automatiquement attribuée"
}
})
cae_situation = relationship(
"CaeSituationOption",
primaryjoin='CaeSituationOption.id==CareerStage.cae_situation_id',
info={
'colanderalchemy':
get_excluded_colanderalchemy(u'Situation dans la CAE'),
'export': {
'related_key': 'label'
},
},
)
stage_type = Column(String(15),
info={
'colanderalchemy': {
'title': u"Type d'étape"
},
'export': {
'formatter':
lambda val: dict(STAGE_TYPE_OPTIONS).get(val),
'stats': {
'options': STAGE_TYPE_OPTIONS
},
}
})
@classmethod
def query(cls, include_inactive=False):
q = super(CareerStage, cls).query()
if not include_inactive:
q = q.filter(CareerStage.active == True)
return q.order_by('name')