class CompetenceSubOption(ConfigurableOption):
__table_args__ = default_table_args
__colanderalchemy_config__ = {"title": u"Sous-compétence"}
id = get_id_foreignkey_col('configurable_option.id')
parent_id = Column(
ForeignKey("competence_option.id"),
info={
'colanderalchemy': EXCLUDED
}
)
parent = relationship(
"CompetenceOption",
primaryjoin="CompetenceOption.id==CompetenceSubOption.parent_id",
cascade="all",
info={
'colanderalchemy': EXCLUDED
},
back_populates='children',
)
def __json__(self, request):
return dict(
id=self.id,
label=self.label,
parent_id=self.parent_id,
)
class CompetenceScale(ConfigurableOption):
__colanderalchemy_config__ = {
'title': u"un niveau à l'échelle d'évaluation",
'validation_msg': u"Les barêmes ont bien été configurés",
"help_msg": u"Configurer les échelles d'évaluation des compétences. \
<br />Dans la grille de compétence, chaque valeur correspondra à une colonne.",
}
id = get_id_foreignkey_col('configurable_option.id')
value = Column(
Float(),
info={
'colanderalchemy': {
'title': u"Valeur numérique",
'description': u"Valeurs utilisées comme unité dans \
les graphiques",
}
}
)
def __json__(self, request):
return dict(
id=self.id,
value=self.value,
label=self.label,
)
@classmethod
def query(cls, *args):
query = super(CompetenceScale, cls).query(*args)
query = query.order_by(CompetenceScale.value)
return query
class PaymentConditions(ConfigurableOption):
__colanderalchemy_config__ = {
'title': u"des conditions de paiement",
'help_msg': u"Configurer les conditions de paiement prédéfinies que \
les entrepreneurs pourront sélectionner lors de la création de leur devis.",
'validation_msg': u"Les conditions de paiement ont bien \
été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
default = Column(Boolean(),
default=False,
info={
'colanderalchemy': {
'title':
u"Valeur par défaut",
'description':
u"Utiliser cette condition pour pré-remplir \
le champ 'Conditions de paiement' du formulaire de création de devis ?",
}
})
def __json__(self, request):
result = ConfigurableOption.__json__(self, request)
result['default'] = self.default
return result
class CaeSituationOption(ConfigurableOption):
"""
Possible values for the cae status "Situation actuelle dans la cae"
"""
__colanderalchemy_config__ = {
'title':
u"Situation dans la CAE",
'validation_msg':
u"Les types de situations ont bien été configurés",
'help_msg':
u"Ce sont les différents statuts que peuvent prendre les \
porteurs de projet peuvent avoir pendant leur parcours au sein de la \
coopérative.<br /><br /><b>La première situation (dans l'ordre \
ci-dessous) \
sera affectée par défaut aux nouveaux porteurs de projet.</b>"
}
id = get_id_foreignkey_col('configurable_option.id')
# Is this element related to the integration process of a PP
is_integration = Column(
Boolean(),
default=False,
info={
'colanderalchemy': {
'title':
'',
'label':
u'Donne droit à un compte Autonomie',
'description':
u"Si un porteur de projet a ce statut, \
un compte Autonomie lui sera automatiquement associé"
}
},
)
class PcsOption(ConfigurableOption):
"""
Different possible value for Pcs
"""
__colanderalchemy_config__ = {
'title': u"Pcs",
'validation_msg': u"Les options pour 'PCS' ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class StudyLevelOption(ConfigurableOption):
"""
Different values for study level
"""
__colanderalchemy_config__ = {
'title': u"Niveau d'étude",
'validation_msg': u"Les niveaux d'étude ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class AntenneOption(ConfigurableOption):
"""
Different antenne
"""
__colanderalchemy_config__ = {
"title": u"Antennes de la CAE",
'validation_msg': u"Les antennes ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class CompanyActivity(ConfigurableOption):
"""
Company activities
"""
__colanderalchemy_config__ = {
'title': u"Domaine d'activité",
'validation_msg': u"Les domaines d'activité ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class ZoneOption(ConfigurableOption):
"""
Different type of geographical zones
"""
__colanderalchemy_config__ = {
'title': u"Zone d'habitation",
'validation_msg': u"Les zones urbaines ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class MotifSortieOption(ConfigurableOption):
"""
Possible values for exit motivation
"""
__colanderalchemy_config__ = {
'title': u"Motif de sortie",
'validation_msg': u"Les motifs de sortie ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class TypeContratOption(ConfigurableOption):
"""
Possible values for contract type
"""
__colanderalchemy_config__ = {
'title': u"Type de contrat",
'validation_msg': u"Les types de contrat ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class ActivityTypeOption(ConfigurableOption):
"""
Different possible values for activity type
"""
__colanderalchemy_config__ = {
'title': u"Typologie des métiers/secteurs d'activité",
'validation_msg': u"Les typologie des métiers ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class TrainingTypeOptions(ConfigurableOption):
"""
Different type of training
"""
__colanderalchemy_config__ = {
'title': u"Type de formation",
'validation_msg': u"Les types de formation ont bien été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
class ParcoursStatusOption(ConfigurableOption):
"""
Possible values for status
"""
__colanderalchemy_config__ = {
'title': u"Statut du parcours",
'validation_msg': u"Les statuts de parcours ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class SocialStatusOption(ConfigurableOption):
"""
Different values for social status
"""
__colanderalchemy_config__ = {
'title': u"Statut social à l'entrée dans la CAE",
'validation_msg': u"Les statuts sociaux ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class ZoneQualificationOption(ConfigurableOption):
"""
Different possible values to qualify a zone
"""
__colanderalchemy_config__ = {
'title': u"Qualificatif des zones d'habitation",
'validation_msg': u"Les qualificatifs de zones urbaines ont bien \
été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class PrescripteurOption(ConfigurableOption):
"""
Different values for prescripteur
"""
__colanderalchemy_config__ = {
'title': u"Prescripteur",
'validation_msg': u"Les différents prescripteurs ont bien \
été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class SocialDocTypeOption(ConfigurableOption):
"""
Different social doc types
"""
__colanderalchemy_config__ = {
"title": u"Type de document sociaux",
'validation_msg': u"Les types de documents sociaux ont \
bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class NonAdmissionOption(ConfigurableOption):
"""
Possible values for refusing admission
"""
__colanderalchemy_config__ = {
'title': u"Motif de non admission",
'validation_msg': u"Les motifs de non admission ont bien \
été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class ParcoursStatusOption(ConfigurableOption):
"""
Possible values for status
"""
__colanderalchemy_config__ = {
'title':
u"Résultat de la visite médicale",
'validation_msg':
u"Les résultats de la visite médicale ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
class CompetenceOption(ConfigurableOption):
"""
A competence model (both for the main one and the sub-competences)
:param int required_id: The id of the bareme element needed
"""
__table_args__ = default_table_args
__colanderalchemy_config__ = {
"title":
u"une compétence",
"validation_msg":
u"La grille de compétences a bien été configurées",
"help_msg":
u"Définissez des compétences, celles-ci sont \
composées: <ul><li>D'un libellé</li><li>D'un niveau de référence</li>\
<li>D'un ensemble de sous-compétences (définies par un libellé)</li></ul>"
}
id = get_id_foreignkey_col('configurable_option.id')
requirement = Column(Float(),
default=0,
info={
'colanderalchemy': {
"title":
u"Niveau de référence pour cette compétence",
"widget":
get_deferred_select(
CompetenceScale,
mandatory=True,
keys=('value', 'label'),
)
}
})
@classmethod
def query(cls, active=True, *args):
query = super(CompetenceOption, cls).query(*args)
query = query.filter_by(active=active)
return query
def __json__(self, request):
return dict(
id=self.id,
label=self.label,
requirement=self.requirement,
children=[child.__json__(request) for child in self.children],
)
@classmethod
def __radar_datas__(cls):
result = []
for option in cls.query():
result.append({'axis': option.label, 'value': option.requirement})
return result
class TaskMention(ConfigurableOption):
__colanderalchemy_config__ = {
"title": u"Mentions facultatives des devis/factures",
"description": u"Configurer les mentions que les entrepreneurs \
peuvent faire figurer dans leurs devis/factures",
}
id = get_id_foreignkey_col('configurable_option.id')
title = sa.Column(
sa.String(255),
default="",
info={
'colanderalchemy': {
"title": u"Titre à afficher dans les PDF",
"description": u"Texte apparaissant sous forme de titre \
dans la sortie PDF (facultatif)"
}
}
)
full_text = sa.Column(
sa.Text(),
info={
'colanderalchemy': {
"title": u"Texte à afficher dans les PDF",
"description": u"Si cette mention a été ajoutée à \
un devis/facture, ce texte apparaitra dans la sortie PDF",
}
},
)
help_text = sa.Column(
sa.String(255),
info={
"colanderalchemy": {
"title": u"Texte d'aide à l'utilisation",
"description": u"Aide fournie à l'entrepreneur dans l'interface"
}
}
)
@property
def is_used(self):
task_query = DBSESSION().query(TASK_MENTION.c.task_id).filter(
TASK_MENTION.c.mention_id == self.id
)
mandatory_query = DBSESSION().query(
MANDATORY_TASK_MENTION.c.task_id
).filter(
MANDATORY_TASK_MENTION.c.mention_id == self.id
)
return DBSESSION().query(task_query.exists()).scalar() or \
DBSESSION().query(mandatory_query.exists()).scalar()
class EmployeeQualityOption(ConfigurableOption):
"""
Different values for employee quality
"""
__colanderalchemy_config__ = {
'title':
u"Qualité du salarié",
'validation_msg':
u"Les qualité du salarié ont bien été configurées",
"help_msg":
u"Configurer les options possibles pour définir la qualité\
d'un salarié (cadre, employé ...)",
}
id = get_id_foreignkey_col('configurable_option.id')
class TaskMention(ConfigurableOption):
__colanderalchemy_config__ = {
"title": u"une mention facultative",
"help_msg": u"Configurer des mentions facultatives pour les devis et \
factures, celles-ci sont proposées aux entrepreneurs dans les formulaires et \
insérées dans les sorties PDF.<br /> \
<b>Libellé</b>: Libellé dans le formulaire<br />\
<b>Titre</b>: Le titre du bloc contenant les mentions dans le PDF <br />\
<b>Texte à afficher dans les PDF</b>: Texte affiché dans la sortie PDF \
si l'entrepreneur a ajouté cette mention à son devis/sa facture<br />.\
<br />\
<b>Note</b> : La suppression d'une mention depuis l'interface entraine sa \
désactivation<br />\
<b>Attention</b> : La modification des textes entrainent la modification \
des documents (devis/factures) associés, préférez la suppression \
(désactivation) et l'ajout de nouvelle mention",
"validation_msg": u"Les mentions facultatives ont bien été configurées"
}
id = get_id_foreignkey_col('configurable_option.id')
title = sa.Column(sa.String(255),
info={
'colanderalchemy': {
"title":
u"Titre",
"description":
u"Titre du bloc contenant les mentions dans \
la sortie pdf",
}
})
full_text = sa.Column(
sa.Text(),
info={
'colanderalchemy': {
"title": u"Texte à afficher dans les PDF",
"description": u"Si l'entrepreneur a ajouté cette mention à \
son devis/sa facture, ce texte apparaitra dans la sortie PDF",
'widget': deform.widget.TextAreaWidget(cols=80, rows=4)
}
},
)
tasks = sa.orm.relationship("Task",
secondary=TASK_MENTION,
back_populates="mentions",
info={'colanderalchemy': {
'exclude': True
}})
class CompetenceDeadline(ConfigurableOption):
__colanderalchemy_config__ = {
'title':
u"une échéance",
'validation_msg':
u"Les échéances ont bien été configurées",
"help_msg":
u"Configurer les échéances à laquelle les compétences des \
entrepreneurs seront évaluées",
}
id = get_id_foreignkey_col('configurable_option.id')
def __json__(self, request):
return dict(
id=self.id,
label=self.label,
)
class PaymentConditions(ConfigurableOption):
__colanderalchemy_config__ = {
'title': u"Conditions de paiement",
'validation_msg': u"Les conditions de paiement ont bien \
été configurées",
}
id = get_id_foreignkey_col('configurable_option.id')
default = Column(Boolean(),
default=False,
info={
'colanderalchemy': {
'title':
u"Valeur par défaut",
'description':
u"Condition de paiement rempliées par défaut ?",
}
})
class BankAccount(ConfigurableOption):
"""
Bank accounts used for payment registry
"""
__colanderalchemy_config__ = {
"title": u"un compte banque",
'validation_msg': u"Les comptes banques ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
code_journal = Column(
String(120),
info={
"colanderalchemy": {
'title':
u"Code journal Banque",
'description':
u"""Code journal utilisé pour les exports
des encaissements et des règlements des notes de dépense""",
}
},
nullable=False,
)
compte_cg = Column(
String(120),
info={"colanderalchemy": {
'title': u"Compte CG Banque"
}},
nullable=False,
)
default = Column(
Boolean(),
default=False,
info={"colanderalchemy": {
'title': u"Utiliser ce compte par défaut"
}})
payments = relationship(
'Payment',
order_by="Payment.date",
info={'colanderalchemy': {
'exclude': True
}},
)
class FileType(ConfigurableOption):
__colanderalchemy_config__ = {
'title': u"Type de documents utilisés dans Autonomie",
'validation_msg': u"Les types de documents ont bien été configurés",
}
id = get_id_foreignkey_col('configurable_option.id')
@property
def is_used(self):
query = DBSESSION().query(File).filter_by(file_type_id=self.id)
file_exists = DBSESSION().query(query.exists()).scalar()
from autonomie.models.indicators import SaleFileRequirement
indicator_query = DBSESSION().query(SaleFileRequirement).filter_by(
file_type_id=self.id)
indicator_exists = DBSESSION().query(indicator_query.exists()).scalar()
return file_exists or indicator_exists
@classmethod
def get_by_label(cls, label):
return cls.query().filter_by(label=label).first()
class CompetenceDeadline(ConfigurableOption):
__colanderalchemy_config__ = {
'title': u"Échéances d'évaluation",
'validation_msg': u"Les échéances ont bien été configurées",
"help_msg": u"Configurer les échéances à laquelle les compétences des \
entrepreneurs seront évaluées",
"seq_widget_options": {
'add_subitem_text_template': u"Ajouter une échéance",
}
}
id = get_id_foreignkey_col('configurable_option.id')
def __json__(self, request):
return dict(
id=self.id,
label=self.label,
)
@classmethod
def query(cls, *args):
query = super(CompetenceDeadline, cls).query(*args)
return query
class CompetenceOption(ConfigurableOption):
"""
A competence model (both for the main one and the sub-competences)
:param int required_id: The id of the bareme element needed
"""
__table_args__ = default_table_args
__colanderalchemy_config__ = {
"title": u"une compétence",
"validation_msg": u"La grille de compétences a bien été configurée",
"help_msg": u"Définissez des compétences, celles-ci sont \
composées: <ul><li>D'un libellé</li>\
<li>D'un ensemble de sous-compétences</li></ul>"
}
id = get_id_foreignkey_col('configurable_option.id')
# To be removed in 3.2
requirement = Column(
Float(),
default=0,
info={'colanderalchemy': {"exclude": True}}
)
children = relationship(
"CompetenceSubOption",
primaryjoin="CompetenceOption.id==CompetenceSubOption.parent_id",
info={
'colanderalchemy': {
'title': u"Sous-compétences associées",
"widget": deform.widget.SequenceWidget(
add_subitem_text_template=u"Ajouter une \
sous-compétence",
min_len=1,
)
},
},
back_populates='parent',
)
@classmethod
def query(cls, active=True, *args):
query = super(CompetenceOption, cls).query(*args)
query = query.filter_by(active=active)
return query
def __json__(self, request):
return dict(
id=self.id,
label=self.label,
requirements=[req.__json__(request) for req in self.requirement],
children=[child.__json__(request) for child in self.children],
)
@classmethod
def __radar_datas__(cls, deadline_id):
result = []
for option in cls.query():
result.append(
{
'axis': option.label,
'value': option.get_requirement(deadline_id)
}
)
return result
def get_requirement(self, deadline_id):
for req in self.requirements:
if req.deadline_id == deadline_id:
return req.requirement
return 0
