def test_connect_anonymous(self):
Params.clear()
self.calljson('/CORE/authentification', {'username': '', 'password': ''})
self.assert_observer('core.auth', 'CORE', 'authentification')
self.assert_json_equal('', '', 'BADAUTH')
param = Parameter.objects.get(name='CORE-connectmode')
param.value = '1'
param.save()
Params.clear()
self.calljson('/CORE/authentification', {'username': '', 'password': ''})
self.assert_observer('core.auth', 'CORE', 'authentification')
self.assert_json_equal('', '', 'OK')
self.assertEqual(self.response_json['connexion']['LOGIN'], '')
self.assertEqual(self.response_json['connexion']['REALNAME'], '')
self.assertEqual(self.response_json['connexion']['MODE'], '1')
self.calljson('/CORE/menu', {})
self.assert_observer('core.menu', 'CORE', 'menu')
self.assertEqual(len(self.response_json['menus']), 1)
self.assertEqual(self.response_json['menus'][0]['id'], 'dummy.foo')
self.assertEqual(self.response_json['menus'][0]['text'], six.text_type('Dummy'))
self.assertEqual(len(self.response_json['menus'][0]['menus']), 6)
def _params(self):
cur_p = self.old_db.open()
cur_p.execute(
"SELECT paramName,value FROM CORE_extension_params WHERE extensionId LIKE 'fr_sdlibre_facture' and paramName in ('ModeTVA','DefaultCompteVente','compteTVAVente','CompteRemise','CompteFraisBank','CompteCaisse')")
for param_name, param_value in cur_p.fetchall():
pname = ''
if param_name == 'ModeTVA':
pname = 'invoice-vat-mode'
if param_value == '':
param_value = '0'
elif param_name == 'DefaultCompteVente':
pname = 'invoice-default-sell-account'
param_value = convert_code(param_value)
elif param_name == 'compteTVAVente':
pname = 'invoice-vatsell-account'
param_value = convert_code(param_value)
elif param_name == 'CompteRemise':
pname = 'invoice-reduce-account'
param_value = convert_code(param_value)
elif param_name == 'CompteFraisBank':
pname = 'payoff-bankcharges-account'
param_value = convert_code(param_value)
elif param_name == 'CompteCaisse':
pname = 'payoff-cash-account'
param_value = convert_code(param_value)
if pname != '':
self.print_debug(
"=> parameter of invoice %s - %s", (pname, param_value))
Parameter.change_value(pname, param_value)
Params.clear()
def get_show_fields(cls):
fields = [
"adherent", "date", ((Params.getvalue("event-degree-text"), 'degree'),)]
if Params.getvalue("event-subdegree-enable") == 1:
fields.append(
((Params.getvalue("event-subdegree-text"), 'subdegree'),))
return fields
def conf_wizard_member(wizard_ident, xfer):
if isinstance(wizard_ident, list) and (xfer is None):
wizard_ident.append(("member_season", 11))
wizard_ident.append(("member_subscriptiontype", 12))
wizard_ident.append(("member_category", 13))
wizard_ident.append(("member_params", 14))
elif (xfer is not None) and (wizard_ident == "member_season"):
xfer.add_title(_("Diacamma member"), _('Season'), _('Configuration of season'))
xfer.fill_grid(5, Season, "season", Season.objects.all())
elif (xfer is not None) and (wizard_ident == "member_subscriptiontype"):
xfer.add_title(_("Diacamma member"), _('Subscriptions'), _('Configuration of subscription'))
xfer.fill_grid(15, SubscriptionType, "subscriptiontype", SubscriptionType.objects.all())
xfer.get_components("subscriptiontype").colspan = 6
fill_params(xfer, ["member-subscription-mode", "member-subscription-message"], True)
elif (xfer is not None) and (wizard_ident == "member_category"):
xfer.add_title(_("Diacamma member"), _("Categories"), _('Configuration of categories'))
xfer.new_tab(_('Parameters'))
fill_params(xfer, ["member-team-enable", "member-team-text", "member-activite-enable", "member-activite-text", "member-age-enable"], True)
if Params.getvalue("member-age-enable") == 1:
xfer.new_tab(_('Age'))
xfer.fill_grid(1, Age, "age", Age.objects.all())
if Params.getvalue("member-team-enable") == 1:
xfer.new_tab(Params.getvalue("member-team-text"))
xfer.fill_grid(1, Team, "team", Team.objects.all())
if Params.getvalue("member-activite-enable") == 1:
xfer.new_tab(Params.getvalue("member-activite-text"))
xfer.fill_grid(1, Activity, "activity", Activity.objects.all())
elif (xfer is not None) and (wizard_ident == "member_params"):
xfer.add_title(_("Diacamma member"), _('Parameters'), _('Configuration of main parameters'))
fill_params(xfer, ["member-licence-enabled", "member-filter-genre", "member-numero", "member-birth", "member-connection"], True)
def _params(self):
cur_p = self.old_db.open()
cur_p.execute(
"SELECT paramName,value FROM CORE_extension_params WHERE extensionId LIKE 'fr_sdlibre_membres' and paramName in ('EquipeEnable', 'EquipeText', 'ActiviteEnable', 'ActiviteText', 'AgeEnable', 'LicenceEnabled', 'FiltreGenre', 'Numero', 'Naissance', 'compteTiersDefault', 'connexion')")
for param_name, param_value in cur_p.fetchall():
pname = ''
if param_name == "EquipeEnable":
pname = "member-team-enable"
if param_name == "EquipeText":
pname = "member-team-text"
if param_name == "ActiviteEnable":
pname = "member-activite-enable"
if param_name == "ActiviteText":
pname = "member-activite-text"
if param_name == "AgeEnable":
pname = "member-age-enable"
if param_name == "LicenceEnabled":
pname = "member-licence-enabled"
if param_name == "FiltreGenre":
pname = "member-filter-genre"
if param_name == "Numero":
pname = "member-numero"
if param_name == "Naissance":
pname = "member-birth"
if param_name == "compteTiersDefault":
pname = "invoice-account-third"
param_value = convert_code(param_value)
if param_name == "connexion":
pname = "member-connection"
if pname != '':
self.print_debug(
"=> parameter of invoice %s - %s", (pname, param_value))
Parameter.change_value(pname, param_value)
Params.clear()
def before_save(self, xfer):
self.item.vta_rate = 0
if (Params.getvalue("invoice-vat-mode") != 0) and (self.item.article is not None) and (self.item.article.vat is not None):
self.item.vta_rate = float(self.item.article.vat.rate / 100)
if Params.getvalue("invoice-vat-mode") == 2:
self.item.vta_rate = -1 * self.item.vta_rate
return
def fillresponse(self):
XferContainerCustom.fillresponse(self)
self.new_tab(_('EMail configuration'))
img = XferCompImage('img_conf')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 6)
self.add_component(img)
conf_params = ['mailing-smtpserver', 'mailing-smtpport',
'mailing-smtpsecurity', 'mailing-smtpuser', 'mailing-smtppass',
'mailing-delay-batch', 'mailing-nb-by-batch']
Params.fill(self, conf_params, 1, 1)
btn = XferCompButton('editparam')
btn.set_location(3, 1, 1, 5)
btn.set_action(self.request, ParamEdit.get_action(_('Modify'), 'images/edit.png'), close=CLOSE_NO, params={'params': conf_params})
self.add_component(btn)
if will_mail_send():
btn = XferCompButton('tryemail')
btn.set_location(1, 10, 2)
btn.set_action(self.request, SendEmailTry.get_action(_('Send'), ''), close=CLOSE_NO)
self.add_component(btn)
self.new_tab(_('Default message'))
img = XferCompImage('img_msg')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 6)
self.add_component(img)
msg_params = ['mailing-msg-connection']
Params.fill(self, msg_params, 1, 1)
btn = XferCompButton('editmsg')
btn.set_location(1, 10, 2)
btn.set_action(self.request, ParamEdit.get_action(_('Modify'), 'images/edit.png'), close=CLOSE_NO, params={'params': msg_params})
self.add_component(btn)
def show(self, xfer):
if xfer.item.cost_accounting is None:
xfer.remove_component("cost_accounting")
xfer.remove_component("lbl_cost_accounting")
xfer.params['new_account'] = Params.getvalue('invoice-account-third')
xfer.move(0, 0, 1)
lbl = XferCompLabelForm('title')
lbl.set_location(1, 0, 4)
lbl.set_value_as_title(get_value_if_choices(
self.item.bill_type, self.item.get_field_by_name('bill_type')))
xfer.add_component(lbl)
details = xfer.get_components('detail')
if Params.getvalue("invoice-vat-mode") != 0:
if Params.getvalue("invoice-vat-mode") == 1:
details.headers[2] = XferCompHeader(details.headers[2].name, _(
'price excl. taxes'), details.headers[2].type, details.headers[2].orderable)
details.headers[6] = XferCompHeader(details.headers[6].name, _(
'total excl. taxes'), details.headers[6].type, details.headers[6].orderable)
elif Params.getvalue("invoice-vat-mode") == 2:
details.headers[2] = XferCompHeader(details.headers[2].name, _(
'price incl. taxes'), details.headers[2].type, details.headers[2].orderable)
details.headers[6] = XferCompHeader(details.headers[6].name, _(
'total incl. taxes'), details.headers[6].type, details.headers[6].orderable)
xfer.get_components('lbl_total_excltax').set_value_as_name(
_('total excl. taxes'))
xfer.filltab_from_model(1, xfer.get_max_row() + 1, True,
[((_('VTA sum'), 'vta_sum'), (_('total incl. taxes'), 'total_incltax'))])
if self.item.status == 0:
SupportingEditor.show_third(self, xfer, 'invoice.add_bill')
else:
SupportingEditor.show_third_ex(self, xfer)
details.actions = []
if self.item.bill_type != 0:
SupportingEditor.show(self, xfer)
return
def get_connection_info(self):
from django.conf import settings
import lucterios.CORE
import os
LucteriosSession.clean_anonymous()
info_cnx = {}
info_cnx['TITLE'] = six.text_type(settings.APPLIS_NAME)
info_cnx['SUBTITLE'] = settings.APPLIS_SUBTITLE()
info_cnx['VERSION'] = six.text_type(settings.APPLIS_VERSION)
info_cnx['SERVERVERSION'] = six.text_type(lucterios.CORE.__version__)
info_cnx['COPYRIGHT'] = six.text_type(settings.APPLIS_COPYRIGHT)
info_cnx['LOGONAME'] = settings.APPLIS_LOGO.decode()
info_cnx['BACKGROUND'] = settings.APPLIS_BACKGROUND.decode()
info_cnx['STYLE'] = settings.APPLIS_STYLE.decode()
info_cnx['SUPPORT_EMAIL'] = six.text_type(settings.APPLI_EMAIL)
info_cnx['SUPPORT_HTML'] = six.text_type(settings.APPLI_SUPPORT())
info_cnx['INFO_SERVER'] = get_info_server()
setting_module_name = os.getenv("DJANGO_SETTINGS_MODULE", "???.???")
info_cnx['INSTANCE'] = setting_module_name.split('.')[0]
info_cnx['MESSAGE_BEFORE'] = Params.getvalue("CORE-MessageBefore")
info_cnx['LANGUAGE'] = self.language
info_cnx['MODE'] = six.text_type(Params.getvalue("CORE-connectmode"))
if self.request.user.is_authenticated:
info_cnx['LOGIN'] = self.request.user.username
info_cnx['REALNAME'] = "%s %s" % (self.request.user.first_name, self.request.user.last_name)
info_cnx['EMAIL'] = self.request.user.email
else:
info_cnx['LOGIN'] = ''
info_cnx['REALNAME'] = ''
info_cnx['EMAIL'] = ''
self.responsejson['connexion'] = info_cnx
def test_params(self):
self.factory.xfer = CategoryConf()
self.call('/diacamma.member/categoryConf', {}, False)
self.assert_observer(
'core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('COMPONENTS/*', 37)
self.assert_count_equal('COMPONENTS/TAB', 4)
self.assert_xml_equal('COMPONENTS/TAB[1]', 'Paramètres')
self.assert_xml_equal('COMPONENTS/TAB[2]', 'Age')
self.assert_xml_equal('COMPONENTS/TAB[3]', 'Équipe')
self.assert_xml_equal('COMPONENTS/TAB[4]', 'Activité')
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="member-team-text"]', 'Équipe')
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="member-activite-text"]', 'Activité')
Parameter.change_value("member-team-text", 'Cours')
Parameter.change_value("member-activite-text", 'Sport')
Params.clear()
self.factory.xfer = CategoryConf()
self.call('/diacamma.member/categoryConf', {}, False)
self.assert_observer(
'core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('COMPONENTS/*', 37)
self.assert_count_equal('COMPONENTS/TAB', 4)
self.assert_xml_equal('COMPONENTS/TAB[1]', 'Paramètres')
self.assert_xml_equal('COMPONENTS/TAB[2]', 'Age')
self.assert_xml_equal('COMPONENTS/TAB[3]', 'Cours')
self.assert_xml_equal('COMPONENTS/TAB[4]', 'Sport')
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="member-team-text"]', 'Cours')
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="member-activite-text"]', 'Sport')
def setUp(self):
self.factory = XmlRequestFactory(self.xfer_class, self.language)
self.client = XmlClient(self.language)
self.response = None
self.clean_resp()
Params.clear()
notfree_mode_connect()
def total(self):
if Params.getvalue("invoice-vat-mode") == 2:
return self.total_incltax
elif Params.getvalue("invoice-vat-mode") == 1:
return self.total_excltax
else:
return format_devise(self.get_total(), 5)
def fillresponse(self, account_system=''):
if account_system != '':
if self.confirme(_('Do you confirm to select "%s" like accounting system?{[br/]}{[br/]}{[i]}{[u]}Warning{[/u]}: This choose is definitive.{[/i]}') %
accounting_system_name(account_system)):
Parameter.change_value('accounting-system', account_system)
Params.clear()
clear_system_account()
def test_payment_billpartial_with_tax(self):
Parameter.change_value('invoice-vat-mode', '2')
Params.clear()
details = [
{'article': 2, 'designation': 'Article 02', 'price': '100.00', 'quantity': 1}]
self._create_bill(details, 1, '2015-04-02', 4, True)
self.factory.xfer = PayoffAddModify()
self.call(
'/diacamma.payoff/payoffAddModify', {'SAVE': 'YES', 'supporting': 6, 'amount': '60.0', 'payer': "Ma'a Dalton", 'date': '2015-04-01', 'mode': 0, 'reference': 'abc', 'bank_account': 0}, False)
self.assert_observer(
'core.acknowledge', 'diacamma.payoff', 'payoffAddModify')
self.factory.xfer = BillShow()
self.call('/diacamma.invoice/billShow', {'bill': 6}, False)
self.assert_observer(
'core.custom', 'diacamma.invoice', 'billShow')
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="title"]', "{[br/]}{[center]}{[u]}{[b]}facture{[/b]}{[/u]}{[/center]}")
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="status"]', "validé")
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="total_rest_topay"]', "40.00€")
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="vta_sum"]', "4.76€")
self.assert_count_equal('ACTIONS/ACTION', 5)
self.assert_action_equal('ACTIONS/ACTION[1]', (six.text_type(
'Règlement'), 'diacamma.payoff/images/payments.png', 'diacamma.payoff', 'payableShow', 0, 1, 1))
self.factory.xfer = PayableShow()
self.call('/diacamma.payoff/supportingPaymentMethod', {'bill': 6, 'item_name': 'bill'}, False)
self.assert_observer('core.custom', 'diacamma.payoff', 'supportingPaymentMethod')
self.assert_xml_equal('COMPONENTS/LABELFORM[@name="num_txt"]', 'A-2')
self.check_payment(6, 'facture A-2 - 2 avril 2015', '38.1', '1.9')
def test_parameters_float(self):
param = Parameter.objects.create(
name='param_float', typeparam=2)
param.args = "{'Min':20, 'Max':30, 'Prec':2}"
param.value = '22.25'
param.save()
Params.fill(self.xfer, ['param_float'], 1, 1, True)
Params.fill(self.xfer, ['param_float'], 1, 2, False)
self.callparam()
self.assert_count_equal('COMPONENTS/*', 4)
self.assert_count_equal(
'COMPONENTS/LABELFORM[@name="lbl_param_float"]', 2)
self.assert_xml_equal(
'COMPONENTS/LABELFORM[@name="param_float"]', '22.25')
self.assert_xml_equal('COMPONENTS/FLOAT[@name="param_float"]', '22.25')
self.assert_attrib_equal(
'COMPONENTS/FLOAT[@name="param_float"]', 'min', '20.0')
self.assert_attrib_equal(
'COMPONENTS/FLOAT[@name="param_float"]', 'max', '30.0')
self.assert_attrib_equal(
'COMPONENTS/FLOAT[@name="param_float"]', 'prec', '2')
self.factory.xfer = ParamSave()
self.call(
'/CORE/paramSave', {'params': 'param_float', 'param_float': '26.87'}, False)
self.assert_observer('core.acknowledge', 'CORE', 'paramSave')
self.assertEqual(Params.getvalue('param_float'), 26.87)
def conf_wizard_contacts(wizard_ident, xfer):
if isinstance(wizard_ident, list) and (xfer is None):
wizard_ident.append(("contacts_current", 5))
wizard_ident.append(("contacts_params", 40))
wizard_ident.append(("contacts_responsable", 41))
elif (xfer is not None) and (wizard_ident == "contacts_current"):
xfer.add_title(_("Lucterios contacts"), _("Our details"), _('configure our details'))
xfer.model = LegalEntity
xfer.item = LegalEntity.objects.get(id=1)
xfer.fill_from_model(1, xfer.get_max_row() + 1, True, desc_fields=LegalEntity.get_show_fields()[_('001@Identity')])
xfer.remove_component('structure_type')
btn = XferCompButton("btnconf")
btn.set_location(2, xfer.get_max_row() + 1)
btn.set_is_mini(True)
btn.set_action(xfer.request, CurrentStructureAddModify.get_action('', "images/edit.png"), close=CLOSE_NO)
xfer.add_component(btn)
elif (xfer is not None) and (wizard_ident == "contacts_params"):
xfer.add_title(_("Lucterios contacts"), _("Contacts configuration"), _('configure your contacts'))
param_lists = ['contacts-mailtoconfig', 'contacts-createaccount']
Params.fill(xfer, param_lists, 1, xfer.get_max_row() + 1)
btn = XferCompButton('editparam')
btn.set_location(4, xfer.get_max_row())
btn.set_is_mini(True)
btn.set_action(xfer.request, ParamEdit.get_action(TITLE_MODIFY, 'images/edit.png'), close=CLOSE_NO,
params={'params': param_lists})
xfer.add_component(btn)
lbl = XferCompLabelForm("nb_function")
lbl.set_location(1, xfer.get_max_row() + 1)
lbl.set_value(TEXT_TOTAL_NUMBER % {'name': Function._meta.verbose_name_plural, 'count': len(Function.objects.all())})
xfer.add_component(lbl)
lbl = XferCompLabelForm("nb_structuretype")
lbl.set_location(1, xfer.get_max_row() + 1)
lbl.set_value(TEXT_TOTAL_NUMBER % {'name': StructureType._meta.verbose_name_plural, 'count': len(StructureType.objects.all())})
xfer.add_component(lbl)
lbl = XferCompLabelForm("nb_customfield")
lbl.set_location(1, xfer.get_max_row() + 1)
lbl.set_value(TEXT_TOTAL_NUMBER % {'name': CustomField._meta.verbose_name_plural, 'count': len(CustomField.objects.all())})
xfer.add_component(lbl)
btn = XferCompButton("btnconf")
btn.set_location(4, xfer.get_max_row() - 2, 1, 3)
btn.set_action(xfer.request, Configuration.get_action(TITLE_MODIFY, "images/edit.png"), close=CLOSE_NO)
xfer.add_component(btn)
lbl = XferCompLabelForm("nb_legalentity")
lbl.set_location(1, xfer.get_max_row() + 1)
lbl.set_value(TEXT_TOTAL_NUMBER % {'name': LegalEntity._meta.verbose_name_plural, 'count': len(LegalEntity.objects.all())})
xfer.add_component(lbl)
lbl = XferCompLabelForm("nb_individual")
lbl.set_location(1, xfer.get_max_row() + 1)
lbl.set_value(TEXT_TOTAL_NUMBER % {'name': Individual._meta.verbose_name_plural, 'count': len(Individual.objects.all())})
xfer.add_component(lbl)
btn = XferCompButton("btnimport")
btn.set_location(4, xfer.get_max_row() - 1, 1, 2)
btn.set_action(xfer.request, ContactImport.get_action(_("Contact import"), "images/add.png"), close=CLOSE_NO, params={'step': 0})
xfer.add_component(btn)
elif (xfer is not None) and (wizard_ident == "contacts_responsable"):
xfer.add_title(_("Lucterios contacts"), _('associates'), _('configure your association'))
xfer.params['legal_entity'] = 1
xfer.fill_grid(5, Responsability, "responsability", Responsability.objects.filter(legal_entity_id=1))
def fill_params(xfer, is_mini=False):
param_lists = ['payoff-cash-account', 'payoff-bankcharges-account', 'payoff-email-message']
Params.fill(xfer, param_lists, 1, xfer.get_max_row() + 1)
btn = XferCompButton('editparam')
btn.set_is_mini(is_mini)
btn.set_location(1, xfer.get_max_row() + 1, 2, 1)
btn.set_action(xfer.request, ParamEdit.get_action(TITLE_MODIFY, 'images/edit.png'), close=CLOSE_NO, params={'params': param_lists})
xfer.add_component(btn)
def fill_params(xfer, is_mini=False):
xfer.params['params'] = ['accounting-devise', 'accounting-devise-iso', 'accounting-devise-prec', 'accounting-sizecode']
Params.fill(xfer, xfer.params['params'], 1, xfer.get_max_row() + 1)
btn = XferCompButton('editparam')
btn.set_is_mini(is_mini)
btn.set_location(1, xfer.get_max_row() + 1, 2, 1)
btn.set_action(xfer.request, ParamEdit.get_action(TITLE_MODIFY, 'images/edit.png'), close=CLOSE_NO)
xfer.add_component(btn)
def setUp(self):
self.xfer_class = XferContainerAcknowledge
self.xfer_class.url_text = "customer/details"
self.xfer_class.is_view_right = ''
LucteriosTest.setUp(self)
self.value = False
self.xfer = XferContainerCustom()
Params.clear()
def __str__(self):
val = []
if Params.getvalue("member-team-enable") and (self.team is not None):
val.append(six.text_type(self.team))
if Params.getvalue("member-activite-enable") and (self.activity is not None):
val.append("[%s]" % six.text_type(self.activity))
if Params.getvalue("member-licence-enabled") and (self.value is not None):
val.append(self.value)
return " ".join(val)
def get_default_fields(cls):
fields = ["contact", (_('subscript?'), 'is_subscripter'), (_('current'), 'current_degree'), (_(
'%s result') % Params.getvalue("event-degree-text"), 'degree_result_simple')]
if Params.getvalue("event-subdegree-enable") == 1:
fields.append(
(_('%s result') % Params.getvalue("event-subdegree-text"), 'subdegree_result'))
fields.append((_('article'), 'article.ref_price'))
fields.append('comment')
return fields
def fill_params(xfer):
param_lists = ["event-degree-text", "event-subdegree-enable",
"event-subdegree-text", "event-comment-text"]
Params.fill(xfer, param_lists, 1, xfer.get_max_row() + 1, nb_col=1)
btn = XferCompButton('editparam')
btn.set_location(1, xfer.get_max_row() + 1, 2, 1)
btn.set_action(xfer.request, ParamEdit.get_action(TITLE_MODIFY, 'images/edit.png'),
close=CLOSE_NO, params={'params': param_lists, 'nb_col': 1})
xfer.add_component(btn)
def fill_params(xfer, param_lists=None, is_mini=False):
if param_lists is None:
param_lists = ['invoice-vat-mode', 'invoice-default-sell-account',
'invoice-vatsell-account', 'invoice-reduce-account', 'invoice-account-third']
Params.fill(xfer, param_lists, 1, xfer.get_max_row() + 1)
btn = XferCompButton('editparam')
btn.set_is_mini(is_mini)
btn.set_location(1, xfer.get_max_row() + 1, 2, 1)
btn.set_action(xfer.request, ParamEdit.get_action(TITLE_MODIFY, 'images/edit.png'), close=CLOSE_NO, params={'params': param_lists})
xfer.add_component(btn)
def get_show_fields(cls):
fields = []
if Params.getvalue("member-team-enable"):
fields.append(((Params.getvalue("member-team-text"), "team"),))
if Params.getvalue("member-activite-enable"):
fields.append(
((Params.getvalue("member-activite-text"), "activity"),))
if Params.getvalue("member-licence-enabled"):
fields.append("value")
return fields
def before_save(self, xfer):
accounts = self.item.third.accountthird_set.filter(code__regex=current_system_account().get_societary_mask())
if len(accounts) == 0:
if Params.getvalue("condominium-old-accounting"):
AccountThird.objects.create(third=self.item.third, code=correct_accounting_code(Params.getvalue("condominium-default-owner-account")))
else:
for num_account in range(1, 5):
AccountThird.objects.create(third=self.item.third,
code=correct_accounting_code(Params.getvalue("condominium-default-owner-account%d" % num_account)))
return SupportingEditor.before_save(self, xfer)
def fillresponse_body(self):
if Params.getvalue("member-age-enable") == 1:
self.new_tab(_('Age'))
self.fill_grid(0, Age, "age", Age.objects.all())
if Params.getvalue("member-team-enable") == 1:
self.new_tab(Params.getvalue("member-team-text"))
self.fill_grid(0, Team, "team", Team.objects.all())
if Params.getvalue("member-activite-enable") == 1:
self.new_tab(Params.getvalue("member-activite-text"))
self.fill_grid(0, Activity, "activity", Activity.objects.all())
def fillresponse(self):
XferListEditor.fillresponse(self)
grid = self.get_components(self.field_id)
grid.colspan = 3
if Params.getvalue("invoice-vat-mode") == 1:
grid.headers[5] = XferCompHeader(grid.headers[5].name, _('total excl. taxes'),
grid.headers[5].type, grid.headers[5].orderable)
elif Params.getvalue("invoice-vat-mode") == 2:
grid.headers[5] = XferCompHeader(grid.headers[5].name, _('total incl. taxes'),
grid.headers[5].type, grid.headers[5].orderable)
def generate_entry(self):
if self.bill_type == 2:
is_bill = -1
else:
is_bill = 1
third_account = self.get_third_account(
current_system_account().get_customer_mask(), self.fiscal_year)
self.entry = EntryAccount.objects.create(
year=self.fiscal_year, date_value=self.date, designation=self.__str__(),
journal=Journal.objects.get(id=3), costaccounting=self.cost_accounting)
EntryLineAccount.objects.create(
account=third_account, amount=is_bill * self.get_total_incltax(), third=self.third, entry=self.entry)
remise_total = 0
detail_list = {}
for detail in self.detail_set.all():
if detail.article is not None:
detail_code = detail.article.sell_account
else:
detail_code = Params.getvalue("invoice-default-sell-account")
detail_account = ChartsAccount.get_account(
detail_code, self.fiscal_year)
if detail_account is None:
raise LucteriosException(
IMPORTANT, _("article has code account unknown!"))
if detail_account.id not in detail_list.keys():
detail_list[detail_account.id] = [detail_account, 0]
detail_list[detail_account.id][
1] += detail.get_total_excltax() + detail.get_reduce_excltax()
remise_total += detail.get_reduce_excltax()
if remise_total > 0.001:
remise_code = Params.getvalue("invoice-reduce-account")
remise_account = ChartsAccount.get_account(
remise_code, self.fiscal_year)
if remise_account is None:
raise LucteriosException(
IMPORTANT, _("reduce-account is not defined!"))
EntryLineAccount.objects.create(
account=remise_account, amount=-1 * is_bill * remise_total, entry=self.entry)
for detail_item in detail_list.values():
EntryLineAccount.objects.create(
account=detail_item[0], amount=is_bill * detail_item[1], entry=self.entry)
if self.get_vta_sum() > 0.001:
vta_code = Params.getvalue("invoice-vatsell-account")
vta_account = ChartsAccount.get_account(
vta_code, self.fiscal_year)
if vta_account is None:
raise LucteriosException(
IMPORTANT, _("vta-account is not defined!"))
EntryLineAccount.objects.create(
account=vta_account, amount=is_bill * self.get_vta_sum(), entry=self.entry)
no_change, debit_rest, credit_rest = self.entry.serial_control(
self.entry.get_serial())
if not no_change or (abs(debit_rest) > 0.001) or (abs(credit_rest) > 0.001):
raise LucteriosException(
GRAVE, _("Error in accounting generator!") + "{[br/]} no_change=%s debit_rest=%.3f credit_rest=%.3f" % (no_change, debit_rest, credit_rest))
def get_import_fields(cls):
fields = super(Individual, cls).get_import_fields()
fields.append(('subscriptiontype', _('subscription type')))
if Params.getvalue("member-team-enable"):
fields.append(('team', Params.getvalue("member-team-text")))
if Params.getvalue("member-activite-enable"):
fields.append(
('activity', Params.getvalue("member-activite-text")))
if Params.getvalue("member-licence-enabled"):
fields.append(('value', _('license #')))
return fields
def get_show_fields(cls):
fields = Individual.get_show_fields()
keys = list(fields.keys())
if Params.getvalue("member-numero"):
fields[keys[0]][0] = ("num", fields[keys[0]][0])
if Params.getvalue("member-birth"):
fields[keys[0]].insert(-1, ("birthday", "birthplace"))
fields[keys[0]].insert(-1, ((_("age category"), "age_category"),))
fields[_('002@Subscription')] = ['subscription_set']
fields[''] = [((_("reference date"), "dateref"),)]
return fields
def initialize_system(self):
Parameter.change_value('accounting-sizecode', 6)
Parameter.change_value('condominium-default-owner-account',
correct_accounting_code(''))
Parameter.change_value('condominium-default-owner-account1',
correct_accounting_code('410100'))
Parameter.change_value('condominium-default-owner-account2',
correct_accounting_code('410000'))
Parameter.change_value('condominium-default-owner-account3',
correct_accounting_code('410100'))
Parameter.change_value('condominium-default-owner-account4',
correct_accounting_code(''))
Parameter.change_value('condominium-default-owner-account5',
correct_accounting_code('410000'))
Parameter.change_value('condominium-current-revenue-account',
correct_accounting_code('701100'))
Parameter.change_value('condominium-exceptional-revenue-account',
correct_accounting_code('700100'))
Parameter.change_value('condominium-advance-revenue-account',
correct_accounting_code('701200'))
Parameter.change_value('condominium-fundforworks-revenue-account',
correct_accounting_code('700000'))
Parameter.change_value('condominium-exceptional-reserve-account',
correct_accounting_code('160000'))
Parameter.change_value('condominium-advance-reserve-account',
correct_accounting_code('100000'))
Parameter.change_value('condominium-fundforworks-reserve-account',
correct_accounting_code('100000'))
Parameter.change_value('condominium-mode-current-callfunds', 1)
Params.clear()
CustomField.objects.get_or_create(modelname='accounting.Third',
name='IBAN',
kind=0,
args="{'multi': False}")
CustomField.objects.get_or_create(modelname='accounting.Third',
name='SWIFT',
kind=0,
args="{'multi': False}")
def test_parameters_bool(self):
param = Parameter.objects.create(name='param_bool', typeparam=3)
param.args = "{}"
param.value = 'False'
param.save()
Params.fill(self.xfer, ['param_bool'], 1, 1, True)
self.callparam()
self.assert_count_equal('', 1)
self.assert_json_equal('LABELFORM', "param_bool", 'Non')
Params.fill(self.xfer, ['param_bool'], 1, 1, False)
self.callparam()
self.assert_count_equal('', 1)
self.assert_json_equal('CHECK', "param_bool", '0')
self.factory.xfer = ParamSave()
self.calljson('/CORE/paramSave', {
'params': 'param_bool',
'param_bool': '1'
}, False)
self.assert_observer('core.acknowledge', 'CORE', 'paramSave')
self.assertEqual(Params.getvalue('param_bool'), True)
def ventilate_result(self, fiscal_year, ventilate):
Owner.throw_not_allowed()
result = fiscal_year.total_revenue - fiscal_year.total_expense
if abs(result) > 0.001:
total_part = PropertyLot.get_total_part()
if total_part > 0:
close_entry = EntryAccount(
year=fiscal_year,
designation=_("Ventilation for %s") % fiscal_year,
journal_id=5)
close_entry.check_date()
close_entry.save()
if ventilate == 0:
amount = 0
biggerowner_val = 0
biggerowner_line = None
for owner in Owner.objects.all():
total = owner.propertylot_set.aggregate(
sum=Sum('value'))
if ('sum' in total.keys()) and (total['sum']
is not None):
value = currency_round(result * total['sum'] /
total_part)
if abs(value) > 0.0001:
owner_account = owner.third.get_account(
fiscal_year, owner.get_third_mask(1))
last_line = EntryLineAccount.objects.create(
account=owner_account,
amount=-1 * value,
entry=close_entry,
third=owner.third)
if biggerowner_val < total['sum']:
biggerowner_val = total['sum']
biggerowner_line = last_line
amount += value
diff = currency_round(result - amount)
if abs(diff) > 0.0001:
biggerowner_line.amount -= diff
biggerowner_line.save()
else:
EntryLineAccount.objects.create(account_id=ventilate,
amount=result,
entry=close_entry)
reserve_account = ChartsAccount.get_account(
Params.getvalue("condominium-current-revenue-account"),
fiscal_year)
EntryLineAccount.objects.create(account=reserve_account,
amount=-1 * result,
entry=close_entry)
close_entry.closed()
def test_parameters_memo(self):
param = Parameter.objects.create(name='param_memo', typeparam=0)
param.args = "{'Multi':True}"
param.value = 'other value'
param.save()
Params.fill(self.xfer, ['param_memo'], 1, 1, True)
self.callparam()
self.assert_count_equal('', 1)
self.assert_json_equal('LABELFORM', "param_memo", 'other value')
Params.fill(self.xfer, ['param_memo'], 1, 1, False)
self.callparam()
self.assert_count_equal('', 1)
self.assert_json_equal('MEMO', "param_memo", 'other value')
self.factory.xfer = ParamSave()
self.calljson('/CORE/paramSave', {
'params': 'param_memo',
'param_memo': 'new special value'
}, False)
self.assert_observer('core.acknowledge', 'CORE', 'paramSave')
self.assertEqual(Params.getvalue('param_memo'), 'new special value')
def CurrentCallFundsAdding(self, to_create):
nb_seq = 0
if Params.getvalue("condominium-mode-current-callfunds") == 0:
nb_seq = 4
if Params.getvalue("condominium-mode-current-callfunds") == 1:
nb_seq = 12
year = FiscalYear.get_current()
calls = CallFunds.objects.filter(date__gte=year.begin,
date__lte=year.end,
calldetail__type_call=0).distinct()
nb_curent = len(calls)
if to_create:
year = FiscalYear.get_current()
date = same_day_months_after(year.begin,
int(nb_curent * 12 / nb_seq))
new_call = CallFunds.objects.create(
date=date,
comment=_(
"Call of funds #%(num)d of year from %(begin)s to %(end)s")
% {
'num': nb_curent + 1,
'begin': get_value_converted(year.begin),
'end': get_value_converted(year.end)
},
status=0)
for category in Set.objects.filter(type_load=0, is_active=True):
CallDetail.objects.create(
set=category,
type_call=0,
callfunds=new_call,
price=category.get_new_current_callfunds(),
designation=_("%(type)s - #%(num)d") % {
'type': _('current'),
'num': nb_curent + 1
})
else:
return nb_curent < nb_seq
def create_dlg(self, username, legalentity):
dlg = self.create_custom(self.model)
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 6)
dlg.add_component(img)
dlg.fill_from_model(1, 0, False,
['genre', 'lastname', 'firstname', 'email'])
dlg.get_components(
'email'
).mask = '^([a-zA-Z0-9_.+-])+\@(([a-zA-Z0-9-_])+\.)+([a-zA-Z0-9]{2,4})+$'
row = dlg.get_max_row() + 1
lbl = XferCompLabelForm("username_lbl")
lbl.set_location(1, row)
lbl.set_value_as_name(_('username'))
dlg.add_component(lbl)
edt = XferCompEdit("username")
edt.set_location(2, row)
edt.set_needed(True)
edt.set_value(username)
dlg.add_component(edt)
if Params.getvalue("contacts-createaccount") == 2:
row = dlg.get_max_row() + 1
lbl = XferCompLabelForm("legalentity_lbl")
lbl.set_location(1, row)
lbl.set_value_as_name(_("your structure name"))
dlg.add_component(lbl)
edt = XferCompEdit("legalentity")
edt.set_location(2, row)
edt.set_needed(True)
edt.set_value(legalentity)
dlg.add_component(edt)
row = dlg.get_max_row() + 1
lbl = XferCompLabelForm("captcha_lbl")
lbl.set_location(1, row)
lbl.set_value_as_name(_("captcha"))
dlg.add_component(lbl)
edt = XferCompCaptcha("captcha")
edt.set_location(2, row)
dlg.add_component(edt)
lbl = XferCompLabelForm("error_lbl")
lbl.set_location(2, row + 1)
lbl.set_color('red')
lbl.set_value(self.getparam('error', ''))
dlg.add_component(lbl)
dlg.add_action(self.get_action(_('Ok'), 'images/ok.png'),
params={"SAVE": "YES"})
dlg.add_action(WrapAction(_('Cancel'), 'images/cancel.png'))
def check_account_config(self):
from diacamma.accounting.tools import current_system_account
try:
lettering_check = Params.getvalue(
"accounting-lettering-check").split('{[br/]}')
changed = False
new_lettering = []
for letter in lettering_check:
if match(current_system_account().get_third_mask(),
letter) is not None:
new_lettering.append(letter)
else:
changed = True
for account in ChartsAccount.objects.filter(
year=FiscalYear.get_current(),
code__regex=current_system_account().get_societary_mask()):
if account.code not in new_lettering:
new_lettering.append(account.code)
changed = True
if changed:
Params.setvalue("accounting-lettering-check",
'{[br/]}'.join(new_lettering))
except LucteriosException:
pass
def security(self):
if self.name == '':
raise AdminException("Instance not precise!")
if not isfile(self.setting_path) or not isfile(self.instance_conf):
raise AdminException("Instance not exists!")
security_param = self.extra
self.read(False)
self.clear_info_()
if SECURITY_PASSWD in security_param.keys():
passwd = self._get_security_password(security_param)
from lucterios.CORE.models import LucteriosUser
adm_user = LucteriosUser.objects.get(username='******')
adm_user.set_password(passwd)
adm_user.save()
self.print_info_("Admin password change in '%s'." % self.name)
if (SECURITY_MODE in security_param.keys()) and (int(
security_param[SECURITY_MODE]) in [0, 1, 2]):
from lucterios.CORE.models import Parameter
from lucterios.CORE.parameters import Params
db_param = Parameter.objects.get(name='CORE-connectmode')
db_param.value = six.text_type(security_param[SECURITY_MODE])
db_param.save()
Params.clear()
self.print_info_("Security mode change in '%s'." % self.name)
def default_params():
Parameter.change_value('member-team-text', 'group')
Parameter.change_value('member-activite-text', 'passion')
Parameter.change_value('member-tax-receipt', '708')
Params.clear()
default = Activity.objects.get(id=1)
default.name = "activity1"
default.description = "activity N°1"
default.save()
Activity.objects.create(name="activity2", description="activity N°2")
Team.objects.create(name="team1", description="team N°1{[br/]}The bests")
Team.objects.create(name="team2",
description="team N°2{[br/]}The chalengers")
Team.objects.create(name="team3", description="team N°3{[br/]}The newbies")
Age.objects.create(name="Poussins", minimum=9, maximum=10)
Age.objects.create(name="Benjamins", minimum=11, maximum=12)
Age.objects.create(name="Minimes", minimum=13, maximum=14)
Age.objects.create(name="Cadets", minimum=15, maximum=16)
Age.objects.create(name="Juniors", minimum=17, maximum=18)
Age.objects.create(name="Espoirs", minimum=19, maximum=21)
Age.objects.create(name="Seniors", minimum=22, maximum=38)
Age.objects.create(name="Vétérans", minimum=39, maximum=108)
Document.objects.create(season=Season.current_season(), name="Doc 1")
Document.objects.create(season=Season.current_season(), name="Doc 2")
def fill_body(self):
line_idx = 0
total1 = 0
total2 = 0
totalb = [0, 0, 0]
revenue_account = Params.getvalue("condominium-current-revenue-account")
initial_filter = self.filter
initial_lastfilter = self.lastfilter
for classloaditem in Set.objects.filter(type_load=0, is_active=True):
first_setcost = classloaditem.setcost_set.filter(year=self.item).first()
if first_setcost is None:
continue
current_costaccounting = first_setcost.cost_accounting
current_request = Q(account__code__regex=current_system_account().get_expence_mask())
current_request |= Q(account__code__regex=current_system_account().get_revenue_mask()) & ~Q(account__code=revenue_account)
if initial_filter is not None:
self.filter = initial_filter & Q(costaccounting_id=current_costaccounting.id)
if initial_lastfilter is not None:
self.lastfilter = initial_lastfilter & Q(costaccounting_id=current_costaccounting.last_costaccounting_id)
query_budget = [~Q(code=revenue_account) & Q(cost_accounting=current_costaccounting)]
if self.next_year is not None:
set_cost = classloaditem.setcost_set.filter(year=self.next_year).first()
if set_cost is None:
set_cost = classloaditem.create_new_cost(year=self.next_year)
query_budget.append(~Q(code=revenue_account) & Q(cost_accounting=set_cost.cost_accounting))
if self.next_year_again is not None:
set_cost = classloaditem.setcost_set.filter(year=self.next_year_again).first()
if set_cost is None:
set_cost = classloaditem.create_new_cost(year=self.next_year_again)
query_budget.append(~Q(code=revenue_account) & Q(cost_accounting=set_cost.cost_accounting))
line__current_dep, subtotal1, subtotal2, subtotalb = self.fill_part_of_grid(current_request, query_budget, line_idx, str(classloaditem), sign_value=False)
line_idx = line__current_dep + 1
total1 += subtotal1
total2 += subtotal2
totalb[0] += subtotalb[0]
if self.next_year is not None:
totalb[1] += subtotalb[1]
if self.next_year_again is not None:
totalb[2] += subtotalb[2]
add_cell_in_grid(self.grid, line_idx, 'design', get_spaces(5) + "{[b]}%s{[/b]}" % _('total'))
add_cell_in_grid(self.grid, line_idx, 'year_n', total1, "{[b]}%s{[/b]}")
add_cell_in_grid(self.grid, line_idx, 'budget_n', totalb[0], "{[b]}%s{[/b]}")
if self.item.last_fiscalyear is not None:
add_cell_in_grid(self.grid, line_idx, 'year_n_1', total2, "{[b]}%s{[/b]}")
if self.next_year is not None:
add_cell_in_grid(self.grid, line_idx, 'budget_n1', totalb[1], "{[b]}%s{[/b]}")
if self.next_year_again is not None:
add_cell_in_grid(self.grid, line_idx, 'budget_n2', totalb[2], "{[b]}%s{[/b]}")
def get_condo_system():
from lucterios.CORE.parameters import Params
complete_name = Params.getvalue("accounting-system")
sys_list = condo_system_list()
if complete_name in sys_list.keys():
modules_long = sys_list[complete_name].split('.')
module_name = ".".join(modules_long[:-1])
class_name = modules_long[-1]
try:
module_sys = import_module(module_name)
class_sys = getattr(module_sys, class_name)
return class_sys()
except (ImportError, AttributeError):
pass
from diacamma.condominium.system.default import DefaultSystemCondo
return DefaultSystemCondo()
def comptenofound_condo(known_codes, accompt_returned):
if Params.getvalue("condominium-old-accounting"):
account_filter = Q(name='condominium-default-owner-account')
set_unknown = Set.objects.exclude(revenue_account__in=known_codes).values_list('revenue_account', flat=True)
else:
account_filter = Q(name='condominium-default-owner-account1') | Q(name='condominium-default-owner-account2') | Q(name='condominium-default-owner-account3') | Q(name='condominium-default-owner-account4')
set_unknown = []
param_unknown = Parameter.objects.filter(account_filter).exclude(value__in=known_codes).values_list('value', flat=True)
comptenofound = ""
if (len(set_unknown) > 0):
comptenofound = _("set") + ":" + ",".join(set(set_unknown)) + " "
if (len(param_unknown) > 0):
comptenofound += _("parameters") + ":" + ",".join(set(param_unknown))
if comptenofound != "":
accompt_returned.append("- {[i]}{[u]}%s{[/u]}: %s{[/i]}" % (_('Condominium'), comptenofound))
return True
def edit(self, xfer):
type_call = xfer.get_components('type_call')
type_call.set_select(
current_system_condo().get_callfunds_list(complete=False))
type_call.set_action(xfer.request,
xfer.return_action(),
close=CLOSE_NO,
modal=FORMTYPE_REFRESH)
set_comp = xfer.get_components('set')
if int(self.item.type_call) == CallDetail.TYPECALL_EXCEPTIONAL:
type_load = 1
else:
type_load = 0
set_list = Set.objects.filter(is_active=True, type_load=type_load)
if len(set_list) == 0:
raise LucteriosException(IMPORTANT,
_('No category of charge defined!'))
set_comp.set_needed(True)
set_comp.set_select_query(set_list)
set_comp.set_action(xfer.request,
xfer.return_action(),
close=CLOSE_NO,
modal=FORMTYPE_REFRESH)
xfer.get_components('price').prec = Params.getvalue(
"accounting-devise-prec")
set_comp.get_json()
current_set = Set.objects.get(id=set_comp.value)
if current_set.type_load == Set.TYPELOAD_CURRENT:
if int(self.item.type_call) == CallDetail.TYPECALL_CURRENT:
xfer.get_components(
'price').value = current_set.get_new_current_callfunds()
elif int(self.item.type_call) == CallDetail.TYPECALL_FUNDFORWORK:
xfer.get_components(
'price').value = current_set.get_current_budget() * 0.05
else:
xfer.get_components('price').value = 0.0
elif current_set.type_load == Set.TYPELOAD_EXCEPTIONAL:
already_called = 0.0
call_details = CallDetail.objects.filter(set_id=set_comp.value)
if self.item.id is not None:
call_details = call_details.exclude(id=self.item.id)
for detail in call_details:
already_called += float(detail.price)
xfer.get_components('price').value = max(
0,
float(current_set.get_current_budget()) -
float(already_called))
def fill_dlg(self):
self.item.can_be_valid()
dlg = self.create_custom()
dlg.item = self.item
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 3)
dlg.add_component(img)
lbl = XferCompLabelForm('title')
lbl.set_value_as_title(self.caption)
lbl.set_location(1, 0, 6)
dlg.add_component(lbl)
dlg.fill_from_model(1, 1, True, ['activity', 'date'])
dlg.get_components('activity').colspan = 3
dlg.get_components('date').colspan = 3
lbl = XferCompLabelForm('sep')
lbl.set_value("{[hr/]}")
lbl.set_location(0, 4, 7)
dlg.add_component(lbl)
row_id = 5
for participant in self.item.participant_set.all():
lbl = XferCompLabelForm('name_%d' % participant.id)
lbl.set_value_as_name(six.text_type(participant))
lbl.set_location(0, row_id)
dlg.add_component(lbl)
lbl = XferCompLabelForm('current_%d' % participant.id)
lbl.set_value(participant.current_degree)
lbl.set_location(1, row_id)
dlg.add_component(lbl)
sel = XferCompSelect('degree_%d' % participant.id)
sel.set_select_query(participant.allow_degree())
sel.set_location(2, row_id)
dlg.add_component(sel)
if Params.getvalue("event-subdegree-enable") == 1:
sel = XferCompSelect('subdegree_%d' % participant.id)
sel.set_select_query(participant.allow_subdegree())
sel.set_location(3, row_id)
dlg.add_component(sel)
edt = XferCompMemo('comment_%d' % participant.id)
edt.set_value(participant.comment)
edt.set_location(4, row_id)
dlg.add_component(edt)
row_id += 1
dlg.add_action(self.get_action(TITLE_OK, "images/ok.png"),
close=CLOSE_YES,
params={'CONFIRME': 'YES'})
dlg.add_action(WrapAction(TITLE_CANCEL, 'images/cancel.png'))
def edit(self, xfer):
if xfer.item.id is None:
sel = XferCompSelect('third')
sel.needed = True
sel.description = _('third')
sel.set_location(1, 0)
owner_third_ids = []
for owner in Owner.objects.all():
owner_third_ids.append(owner.third_id)
items = Third.objects.all().exclude(
id__in=owner_third_ids).distinct()
items = sorted(items, key=lambda t: six.text_type(t))
sel.set_select_query(items)
xfer.add_component(sel)
btn = XferCompButton('add_third')
btn.set_location(3, 0)
btn.set_is_mini(True)
btn.set_action(
xfer.request,
ActionsManage.get_action_url('accounting.Third', 'Add', xfer),
close=CLOSE_NO,
modal=FORMTYPE_MODAL,
params={
'new_account':
Params.getvalue('condominium-default-owner-account')
})
xfer.add_component(btn)
xfer.filltab_from_model(1,
xfer.get_max_row() + 1, False,
["information"])
else:
old_item = xfer.item
xfer.item = old_item.third.contact.get_final_child()
xfer.filltab_from_model(1, 0, False, xfer.item.get_edit_fields())
CustomField.edit_fields(xfer, 1)
xfer.item = old_item.third.get_final_child()
xfer.filltab_from_model(1,
xfer.get_max_row() + 1, False,
xfer.item.get_edit_fields())
CustomField.edit_fields(xfer, 1)
xfer.item = old_item
xfer.filltab_from_model(1,
xfer.get_max_row() + 1, False,
["information"])
def test_params(self):
self.factory.xfer = EventConf()
self.calljson('/diacamma.event/eventConf', {}, False)
self.assert_observer('core.custom', 'diacamma.event', 'eventConf')
self.assert_count_equal('', 2 + 2 + 2 + 7)
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Diplôme')
self.assert_json_equal('TAB', '__tab_3', 'Sous-diplôme')
self.assertFalse('__tab_4' in self.json_data.keys(), self.json_data.keys())
self.assert_json_equal('LABELFORM', 'event-degree-text', 'Diplôme')
self.assert_json_equal('LABELFORM', 'event-subdegree-text', 'Sous-diplôme')
Parameter.change_value("event-degree-text", 'Grade')
Parameter.change_value("event-subdegree-text", 'Barette')
Params.clear()
self.factory.xfer = EventConf()
self.calljson('/diacamma.event/eventConf', {}, False)
self.assert_observer('core.custom', 'diacamma.event', 'eventConf')
self.assert_count_equal('', 2 + 2 + 2 + 7)
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Grade')
self.assert_json_equal('TAB', '__tab_3', 'Barette')
self.assertFalse('__tab_4' in self.json_data.keys(), self.json_data.keys())
self.assert_json_equal('LABELFORM', 'event-degree-text', 'Grade')
self.assert_json_equal('LABELFORM', 'event-subdegree-text', 'Barette')
self.assert_json_equal('LABELFORM', 'event-subdegree-enable', 'Oui')
self.assert_json_equal('LABELFORM', 'event-degree-enable', 'Oui')
Parameter.change_value("event-subdegree-enable", 0)
Params.clear()
self.factory.xfer = EventConf()
self.calljson('/diacamma.event/eventConf', {}, False)
self.assert_observer('core.custom', 'diacamma.event', 'eventConf')
self.assert_count_equal('', 2 + 2 + 7)
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Grade')
self.assertFalse('__tab_3' in self.json_data.keys(), self.json_data.keys())
self.assert_json_equal('LABELFORM', 'event-subdegree-enable', 'Non')
self.assert_json_equal('LABELFORM', 'event-degree-enable', 'Oui')
Parameter.change_value("event-degree-enable", 0)
Params.clear()
self.factory.xfer = EventConf()
self.calljson('/diacamma.event/eventConf', {}, False)
self.assert_observer('core.custom', 'diacamma.event', 'eventConf')
self.assert_count_equal('', 2 + 7)
self.assertFalse('__tab_2' in self.json_data.keys(), self.json_data.keys())
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('LABELFORM', 'event-subdegree-enable', 'Non')
self.assert_json_equal('LABELFORM', 'event-degree-enable', 'Non')
def fill_third_convert(self, dlg):
lbl = XferCompLabelForm('tle_third')
lbl.set_value(_('How do want to convert owner third account?'))
lbl.set_location(0, 0, 2)
dlg.add_component(lbl)
select_account = [('', None)]
for num_account in range(1, 6):
owner_account = correct_accounting_code(Params.getvalue('condominium-default-owner-account%d' % num_account))
select_account.append((owner_account, owner_account))
row = 1
for code_item in AccountThird.objects.filter(code__regex=r"^45[0-9a-zA-Z]*$", third__status=0).values_list('code').distinct():
sel = XferCompSelect('code_' + code_item[0])
sel.set_location(0, row)
sel.description = code_item[0]
sel.set_value(dlg.getparam('code_' + code_item[0], ""))
sel.set_select(select_account)
dlg.add_component(sel)
row += 1
def edit(self, xfer):
IndividualEditor.edit(self, xfer)
birthday = xfer.get_components('birthday')
if birthday is not None:
birthday.needed = True
if (self.item.id is None) and (xfer.getparam(
'legal_entity',
0) == 0) and (Params.getobject("member-family-type")
is not None):
genre = xfer.get_components('genre')
genre.colspan -= 1
btn = XferCompButton('famillybtn')
btn.set_location(genre.col + genre.colspan, genre.row)
btn.set_action(xfer.request,
ActionsManage.get_action_url(
'member.Adherent', 'familyAdherentAdd', xfer),
modal=FORMTYPE_MODAL,
close=CLOSE_YES)
xfer.add_component(btn)
def fillresponse(self):
XferListEditor.fillresponse(self)
self.new_tab(_("Log setting"))
row = self.get_max_row() + 1
sel = XferCompCheckList('AuditLogSetting')
sel.simple = 2
sel.set_select(Signal.get_packages_of_signal('auditlog_register'))
sel.set_value(Params.getvalue('CORE-AuditLog').split())
sel.set_location(1, row, 3)
sel.description = _('settings')
self.add_component(sel)
btn = XferCompButton('ChangeAL')
btn.set_action(self.request,
AudiLogChange.get_action(TITLE_MODIFY,
"images/edit.png"),
modal=FORMTYPE_MODAL,
close=CLOSE_NO)
btn.set_location(2, row + 1)
self.add_component(btn)
def save(self,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
if (self.id is None) and (self.event.event_type == 0) and (
(self.comment is None) or (self.comment == '')):
self.comment = Params.getvalue("event-comment-text")
if (self.id is None) and self.is_subscripter and (
self.event.default_article is not None):
self.article = self.event.default_article
if (self.id is None) and not self.is_subscripter and (
self.event.default_article_nomember is not None):
self.article = self.event.default_article_nomember
return LucteriosModel.save(self,
force_insert=force_insert,
force_update=force_update,
using=using,
update_fields=update_fields)
def add_email_selector(self, xfer, col, row, colspan):
contacts_list = xfer.items.exclude(email__isnull=True).exclude(email__exact='')
if len(contacts_list) < 100:
mailto_type = Params.getvalue("contacts-mailtoconfig")
email_list = []
for item in contacts_list:
email_list.append(six.text_type(item.email))
if len(email_list) > 0:
link = XferCompLinkLabel('emailAll')
link.set_value_center(_('Write to all'))
if mailto_type == 1: # CC
mailto_prefix = 'mailto:?cc='
elif mailto_type == 2: # BCC
mailto_prefix = 'mailto:?bcc='
else: # TO
mailto_prefix = 'mailto:'
link.set_link(mailto_prefix + ','.join(email_list))
link.set_location(col, row, colspan)
xfer.add_component(link)
def finalizeyear_condo(xfer):
year = FiscalYear.get_current(xfer.getparam('year'))
if year is not None:
ventilate = xfer.getparam("ventilate", 0)
if xfer.observer_name == "core.custom":
if year.check_to_close() > 0:
raise LucteriosException(
IMPORTANT, _("This fiscal year has entries not closed!"))
result = year.total_revenue - year.total_expense
if abs(result) > 0.001:
row = xfer.get_max_row() + 1
lbl = XferCompLabelForm('title_condo')
lbl.set_value(
_('This fiscal year has a result no null equals to %s.') %
get_amount_from_format_devise(result, 7))
lbl.set_location(0, row, 2)
xfer.add_component(lbl)
lbl = XferCompLabelForm('question_condo')
lbl.set_value(_('Where do you want to ventilate this amount?'))
lbl.set_location(0, row + 1)
xfer.add_component(lbl)
sel_cmpt = [('0', _("For each owner"))]
for account in year.chartsaccount_set.filter(
type_of_account=2).order_by('code'):
sel_cmpt.append((account.id, str(account)))
sel = XferCompSelect("ventilate")
sel.set_select(sel_cmpt)
sel.set_value(ventilate)
sel.set_location(1, row + 1)
xfer.add_component(sel)
elif xfer.observer_name == "core.acknowledge":
Owner.ventilate_pay_all(year.begin, year.end)
for set_cost in year.setcost_set.filter(year=year,
set__is_active=True,
set__type_load=0):
if ventilate == 0:
current_system_condo().ventilate_costaccounting(
year, set_cost.set, set_cost.cost_accounting,
DEFAULT_ACCOUNT_CURRENT,
Params.getvalue("condominium-current-revenue-account"))
set_cost.cost_accounting.close()
current_system_condo().ventilate_result(year, ventilate)
def summary_condo(xfer):
if not hasattr(xfer, 'add_component'):
return WrapAction.is_permission(xfer, 'condominium.change_set')
else:
if WrapAction.is_permission(xfer.request, 'condominium.change_set'):
row = xfer.get_max_row() + 1
lab = XferCompLabelForm('condotitle')
lab.set_value_as_infocenter(_('Condominium'))
lab.set_location(0, row, 4)
xfer.add_component(lab)
nb_set = len(Set.objects.filter(is_active=True))
nb_owner = len(Owner.objects.all())
lab = XferCompLabelForm('condoinfo')
lab.set_value_as_header(_("There are %(set)d classes of loads for %(owner)d owners") % {'set': nb_set, 'owner': nb_owner})
lab.set_location(0, row + 1, 4)
xfer.add_component(lab)
if Params.getvalue("condominium-old-accounting"):
lab = XferCompLabelForm('condoconvinfo')
lab.set_value_as_header(_("Your condominium account is not in respect of French law{[newline]}An conversion is necessary."))
lab.set_color('red')
lab.set_location(0, row + 2, 4)
xfer.add_component(lab)
btn = XferCompButton('condoconv')
btn.set_location(0, row + 3, 4)
btn.set_action(xfer.request, CondominiumConvert.get_action(_('Convertion ...'), ""), close=CLOSE_NO)
xfer.add_component(btn)
if hasattr(settings, "DIACAMMA_MAXOWNER"):
lbl = XferCompLabelForm("limit_owner")
lbl.set_value(_('limitation: %d owners allowed') % getattr(settings, "DIACAMMA_MAXOWNER"))
lbl.set_italic()
lbl.set_location(0, row + 4, 4)
xfer.add_component(lbl)
row = xfer.get_max_row() + 1
lab = XferCompLabelForm('condosep')
lab.set_value_as_infocenter("{[hr/]}")
lab.set_location(0, row, 4)
xfer.add_component(lab)
return True
else:
return False
def fill_body(self):
line_idx = 0
total1 = 0
total2 = 0
totalb = [0]
revenue_account = Params.getvalue(
"condominium-exceptional-revenue-account")
for classloaditem in Set.objects.filter(type_load=1, is_active=True):
current_request = Q(account__code__regex=current_system_account().
get_expence_mask())
current_request |= Q(account__code__regex=current_system_account(
).get_revenue_mask()) & ~Q(account__code=revenue_account)
current_request &= Q(costaccounting__setcost__set=classloaditem)
query_budget = [
~Q(code=revenue_account)
& Q(cost_accounting=classloaditem.current_cost_accounting)
& Q(year=self.item)
]
line__current_dep, subtotal1, subtotal2, subtotalb = self.fill_part_of_grid(
current_request,
query_budget,
line_idx,
six.text_type(classloaditem),
sign_value=False)
total_call = classloaditem.get_total_calloffund(self.item)
add_cell_in_grid(self.grid, line__current_dep - 1, 'calloffund',
"{[u]}%s{[/u]}" % format_devise(total_call, 5))
add_cell_in_grid(
self.grid, line__current_dep - 1, 'result',
"{[u]}%s{[/u]}" % format_devise(total_call - subtotal1, 5))
line_idx = line__current_dep + 1
total1 += subtotal1
total2 += subtotal2
totalb[0] += subtotalb[0]
add_cell_in_grid(self.grid, line_idx, 'design',
get_spaces(5) + "{[b]}%s{[/b]}" % _('total'))
add_cell_in_grid(self.grid, line_idx, 'year_n',
"{[b]}%s{[/b]}" % format_devise(total1, 5))
add_cell_in_grid(self.grid, line_idx, 'budget_n',
"{[b]}%s{[/b]}" % format_devise(totalb[0], 5))
def default_setowner_fr(with_lots=True):
RecoverableLoadRatio.objects.create(code='602', ratio=60)
RecoverableLoadRatio.objects.create(code='604', ratio=40)
if Params.getvalue("condominium-old-accounting"):
create_account(['450'], 0, FiscalYear.get_current())
else:
create_account(['4501', '4502', '4503', '4504', '4505'], 0,
FiscalYear.get_current()) # 17 18 19 20 21
create_account(['120', '103', '105'], 2,
FiscalYear.get_current()) # 22 23 24
create_account(['702', '705'], 3, FiscalYear.get_current()) # 25 26
set1 = Set.objects.create(name="AAA",
budget=1000,
revenue_account='701',
is_link_to_lots=with_lots,
type_load=0)
_set_budget(set1, '604', 1000)
set2 = Set.objects.create(name="BBB",
budget=100,
revenue_account='701',
type_load=0)
_set_budget(set2, '604', 100)
set3 = Set.objects.create(name="CCC",
budget=500,
revenue_account='702',
type_load=1)
_set_budget(set3, '604', 500)
set4 = Set.objects.create(name="OLD",
budget=100,
revenue_account='702',
type_load=1,
is_active=False)
_set_budget(set4, '602', 100)
_create_owners(set1, set2, set3, set4, with_lots)
Owner.check_all_account()
def send_email(recipients,
subject,
body,
files=None,
cclist=None,
bcclist=None,
withcopy=False,
body_txt=None):
from lucterios.CORE.parameters import Params
from lucterios.contacts.models import LegalEntity
smtp_server = Params.getvalue('mailing-smtpserver')
smtp_port = Params.getvalue('mailing-smtpport')
smtp_user = Params.getvalue('mailing-smtpuser')
smtp_pass = Params.getvalue('mailing-smtppass')
smtp_security = Params.getvalue('mailing-smtpsecurity')
sender_obj = LegalEntity.objects.get(id=1)
sender_name = sender_obj.name
sender_email = sender_obj.email
if (sender_email == '') or ((smtp_server == '') and (smtp_security != 3)):
raise EmailException(_('Email not configure!'))
if recipients is None:
recipients = sender_email
if not isinstance(recipients, list):
recipients = [six.text_type(recipients)]
recipients = split_doubled_email(recipients)
dkim_private_path = Params.getvalue('mailing-dkim-private-path')
dkim_selector = Params.getvalue('mailing-dkim-selector')
if withcopy:
if bcclist is None:
bcclist = []
if sender_email not in bcclist:
bcclist.append(sender_email)
email_server = get_email_server(smtp_security, smtp_server, smtp_port,
smtp_user, smtp_pass)
return sending_email(recipients, sender_name, sender_email, subject, body,
body_txt, files, cclist, bcclist, email_server,
dkim_private_path, dkim_selector)
def test_params(self):
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assertFalse('__tab_5' in self.json_data.keys(),
self.json_data.keys())
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Âge')
self.assert_json_equal('TAB', '__tab_3', 'Équipe')
self.assert_json_equal('TAB', '__tab_4', 'Activité')
self.assert_json_equal('LABELFORM', 'member-team-text', 'Équipe')
self.assert_json_equal('LABELFORM', 'member-activite-text', 'Activité')
self.assert_json_equal(
'LABELFORM', 'member-fields',
"N°{[br/]}prénom{[br/]}nom{[br/]}tel1{[br/]}tel2{[br/]}courriel{[br/]}participation"
)
self.assert_json_equal('', '#editparam/action/action',
'categoryParamEdit')
self.factory.xfer = CategoryParamEdit()
self.calljson(
'/diacamma.member/categoryParamEdit', {
'params':
";".join([
"member-team-enable", "member-team-text",
"member-activite-enable", "member-activite-text",
"member-age-enable", "member-licence-enabled",
"member-filter-genre", "member-numero", "member-birth",
"member-family-type", "member-connection",
"member-subscription-mode", "member-size-page",
"member-fields", "member-subscription-message"
])
}, False)
self.assert_observer('core.custom', 'diacamma.member',
'categoryParamEdit')
self.assert_json_equal('SELECT', 'member-size-page', '25')
self.assert_select_equal('member-size-page', 5)
self.assert_json_equal('CHECKLIST', 'member-fields', [
'num', 'firstname', 'lastname', 'tel1', 'tel2', 'email', 'license'
])
self.assert_select_equal('member-fields', 17, checked=True)
Parameter.change_value("member-team-text", 'Cours')
Parameter.change_value("member-activite-text", 'Sport')
Parameter.change_value("member-fields",
"firstname;lastname;email;documents")
Params.clear()
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assertFalse('__tab_5' in self.json_data.keys(),
self.json_data.keys())
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Âge')
self.assert_json_equal('TAB', '__tab_3', 'Cours')
self.assert_json_equal('TAB', '__tab_4', 'Sport')
self.assert_json_equal('LABELFORM', 'member-team-text', 'Cours')
self.assert_json_equal('LABELFORM', 'member-activite-text', 'Sport')
self.assert_json_equal(
'LABELFORM', 'member-fields',
"prénom{[br/]}nom{[br/]}courriel{[br/]}documents demandés")
def test_age(self):
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assert_grid_equal('age', {
'name': "nom",
'date_min': "date min.",
'date_max': "date max."
}, 0)
self.factory.xfer = AgeAddModify()
self.calljson('/diacamma.member/ageAddModify', {}, False)
self.assert_observer('core.exception', 'diacamma.member',
'ageAddModify')
default_season()
self.factory.xfer = AgeAddModify()
self.calljson('/diacamma.member/ageAddModify', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'ageAddModify')
self.assert_count_equal('', 4)
self.factory.xfer = AgeAddModify()
self.calljson('/diacamma.member/ageAddModify', {
"SAVE": "YES",
"name": "xyz",
"date_min": "1981",
"date_max": "1980"
}, False)
self.assert_observer('core.exception', 'diacamma.member',
'ageAddModify')
self.factory.xfer = AgeAddModify()
self.calljson('/diacamma.member/ageAddModify', {
"SAVE": "YES",
"name": "xyz",
"date_min": "1980",
"date_max": "1981"
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'ageAddModify')
self.factory.xfer = AgeAddModify()
self.calljson('/diacamma.member/ageAddModify', {
"SAVE": "YES",
"name": "uvw",
"date_min": "1979",
"date_max": "1980"
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'ageAddModify')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('age', 2)
self.assert_json_equal('', 'age/@0/name', "uvw")
self.assert_json_equal('', 'age/@0/date_min', "1979")
self.assert_json_equal('', 'age/@0/date_max', "1980")
self.assert_json_equal('', 'age/@1/name', "xyz")
self.assert_json_equal('', 'age/@1/date_min', "1980")
self.assert_json_equal('', 'age/@1/date_max', "1981")
self.factory.xfer = SeasonActive()
self.calljson('/diacamma.member/seasonActive', {'season': 12}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'seasonActive')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('age', 2)
self.assert_json_equal('', 'age/@0/name', "uvw")
self.assert_json_equal('', 'age/@0/date_min', "1981")
self.assert_json_equal('', 'age/@0/date_max', "1982")
self.assert_json_equal('', 'age/@1/name', "xyz")
self.assert_json_equal('', 'age/@1/date_min', "1982")
self.assert_json_equal('', 'age/@1/date_max', "1983")
self.assert_json_equal('LABELFORM', 'member-age-enable', 'Oui')
self.factory.xfer = AgeDel()
self.calljson('/diacamma.member/ageDel', {
"CONFIRME": "YES",
"age": 1
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member', 'ageDel')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('age', 1)
Parameter.change_value("member-age-enable", '0')
Params.clear()
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 0 + 3 + 2)
self.assert_json_equal('LABELFORM', 'member-age-enable', 'Non')
self.assertFalse('__tab_4' in self.json_data.keys(),
self.json_data.keys())
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Équipe')
self.assert_json_equal('TAB', '__tab_3', 'Activité')
def test_team(self):
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assert_grid_equal('team', {
'name': "nom",
'description': "description"
}, 0)
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf',
{'show_only_enabled_team': False}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assert_grid_equal('team', {
'name': "nom",
'description': "description",
'unactive': "désactivé"
}, 0)
self.factory.xfer = TeamAddModify()
self.calljson('/diacamma.member/teamAddModify', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'teamAddModify')
self.assert_count_equal('', 4)
self.factory.xfer = TeamAddModify()
self.calljson('/diacamma.member/teamAddModify', {
"SAVE": "YES",
"name": "xyz",
"description": "abc",
'unactive': 0
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'teamAddModify')
self.factory.xfer = TeamAddModify()
self.calljson('/diacamma.member/teamAddModify', {
"SAVE": "YES",
"name": "uvw",
"description": "def",
'unactive': 1
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'teamAddModify')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf',
{'show_only_enabled_team': False}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('team', 2)
self.assert_json_equal('', 'team/@0/name', "uvw")
self.assert_json_equal('', 'team/@0/unactive', True)
self.assert_json_equal('', 'team/@1/name', "xyz")
self.assert_json_equal('', 'team/@1/unactive', False)
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf',
{'show_only_enabled_team': True}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('team', 1)
self.assert_json_equal('', 'team/@0/name', "xyz")
self.factory.xfer = TeamDel()
self.calljson('/diacamma.member/teamDel', {
"CONFIRME": "YES",
"team": 1
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member', 'teamDel')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('team', 0)
Parameter.change_value("member-team-enable", '0')
Params.clear()
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 0 + 2)
self.assert_json_equal('LABELFORM', 'member-team-enable', 'Non')
self.assertFalse('__tab_4' in self.json_data.keys(),
self.json_data.keys())
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Âge')
self.assert_json_equal('TAB', '__tab_3', 'Activité')
def test_activity(self):
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 2)
self.assert_grid_equal('activity', {
'name': "nom",
'description': "description"
}, 1)
self.factory.xfer = ActivityAddModify()
self.calljson('/diacamma.member/activityAddModify', {}, False)
self.assert_observer('core.custom', 'diacamma.member',
'activityAddModify')
self.assert_count_equal('', 3)
self.factory.xfer = ActivityAddModify()
self.calljson('/diacamma.member/activityAddModify', {
"SAVE": "YES",
"name": "xyz",
"description": "abc"
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'activityAddModify')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('activity', 2)
self.assert_json_equal('', 'activity/@1/name', "xyz")
self.factory.xfer = ActivityDel()
self.calljson('/diacamma.member/activityDel', {
"CONFIRME": "YES",
"activity": 2
}, False)
self.assert_observer('core.acknowledge', 'diacamma.member',
'activityDel')
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('activity', 1)
self.factory.xfer = ActivityDel()
self.calljson('/diacamma.member/activityDel', {
"CONFIRME": "YES",
"activity": 1
}, False)
self.assert_observer('core.exception', 'diacamma.member',
'activityDel')
Parameter.change_value("member-activite-enable", '0')
Params.clear()
self.factory.xfer = CategoryConf()
self.calljson('/diacamma.member/categoryConf', {}, False)
self.assert_observer('core.custom', 'diacamma.member', 'categoryConf')
self.assert_count_equal('', 2 + 13 + 2 + 3 + 0)
self.assert_json_equal('LABELFORM', 'member-activite-enable', 'Non')
self.assert_json_equal('TAB', '__tab_1', 'Paramètres')
self.assert_json_equal('TAB', '__tab_2', 'Âge')
self.assert_json_equal('TAB', '__tab_3', 'Équipe')
self.assertFalse('__tab_4' in self.json_data.keys(),
self.json_data.keys())
