def dedicated_accounts_summaries(request): """ Accounts summaries for dedicated accounts. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='gi_bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) query_data = [] # Compte dédié Eusko billet: compte_dedie_eusko_billet # Compte dédié Eusko numérique: compte_dedie_eusko_numerique query_data_billet = [str(settings.CYCLOS_CONSTANTS['users']['compte_dedie_eusko_billet']), None] query_data.extend(cyclos.post(method='account/getAccountsSummary', data=query_data_billet)['result']) query_data_numerique = [str(settings.CYCLOS_CONSTANTS['users']['compte_dedie_eusko_numerique']), None] query_data.extend(cyclos.post(method='account/getAccountsSummary', data=query_data_numerique)['result']) res = {} filter_keys = ['compte_dedie_eusko_billet', 'compte_dedie_eusko_numerique'] for filter_key in filter_keys: data = [item for item in query_data if item['owner']['id'] == str(settings.CYCLOS_CONSTANTS['users'][filter_key])][0] res[filter_key] = {} res[filter_key]['id'] = data['id'] res[filter_key]['balance'] = float(data['status']['balance']) res[filter_key]['currency'] = data['currency']['symbol'] res[filter_key]['type'] = {'name': data['type']['name'], 'id': filter_key} return Response(res)
def payments_available_for_adherents(request): serializer = serializers.HistorySerializer(data=request.query_params) serializer.is_valid(raise_exception=True) try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) begin_date = serializer.data['begin'].replace(hour=0, minute=0, second=0).isoformat() end_date = serializer.data['end'].replace(hour=23, minute=59, second=59).isoformat() query_data = [cyclos.user_id, end_date] accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=query_data) search_history_data = { 'orderBy': 'DATE_DESC', 'pageSize': 1000, # maximum pageSize: 1000 'currentPage': 0, 'period': { 'begin': begin_date, 'end': end_date, }, } try: search_history_data.update( {'account': request.query_params['account']}) except KeyError: search_history_data.update({ 'account': accounts_summaries_data['result'][0]['status']['accountId'] }) try: search_history_data.update( {'description': request.query_params['description']}) except KeyError: pass accounts_history_res = cyclos.post(method='account/searchAccountHistory', data=search_history_data) return Response([ accounts_history_res, accounts_summaries_data['result'][0]['status']['balance'] ])
def system_accounts_summaries(request): """ List all system_accounts_summaries. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='gi_bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # account/getAccountsSummary query_data = ['SYSTEM', None] accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=query_data) # Stock de billets: stock_de_billets # Compte de transit: compte_de_transit res = {} filter_keys = ['stock_de_billets', 'compte_de_transit'] for filter_key in filter_keys: data = [item for item in accounts_summaries_data['result'] if item['type']['id'] == str(settings.CYCLOS_CONSTANTS['account_types'][filter_key])][0] res[filter_key] = {} res[filter_key]['id'] = data['id'] res[filter_key]['balance'] = float(data['status']['balance']) res[filter_key]['currency'] = data['currency']['symbol'] res[filter_key]['type'] = {'name': data['type']['name'], 'id': filter_key} return Response(res)
def reconvert_eusko(request): """ Transfer d'eusko entre compte de particulier. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.ReconvertEuskoSerializer(data=request.data) serializer.is_valid( raise_exception=True) # log.critical(serializer.errors) # payment/perform query_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types'] ['reconversion_numerique']), 'amount': serializer.data['amount'], 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': serializer.data['debit'], 'to': 'SYSTEM', 'description': serializer.data['description'], } return Response(cyclos.post(method='payment/perform', data=query_data))
def one_time_transfer(request): """ Transfer d'eusko entre compte d'adhérent. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.OneTimeTransferSerializer(data=request.data) serializer.is_valid( raise_exception=True) # log.critical(serializer.errors) # payment/perform query_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types'] ['virement_inter_adherent']), 'amount': serializer.data['amount'], 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': serializer.data['debit'], 'to': serializer.data['beneficiaire'], 'description': serializer.data['description'], } return Response(cyclos.post(method='payment/perform', data=query_data))
def has_account(request): try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') # Determine whether or not our user is an "utilisateur" or a "prestataire" group_constants_without_account = [ str(settings.CYCLOS_CONSTANTS['groups']['adherents_sans_compte']) ] group_constants_with_account = [ str(settings.CYCLOS_CONSTANTS['groups']['adherents_prestataires']), str(settings.CYCLOS_CONSTANTS['groups']['adherents_utilisateurs']) ] # Fetching info for our current user (we look for his groups) data = cyclos.post(method='user/load', data=[cyclos.user_id], token=request.user.profile.cyclos_token) # Determine whether or not our user is part of the appropriate group if data['result']['group']['id'] in group_constants_without_account: return Response({'status': False}) elif data['result']['group']['id'] in group_constants_with_account: return Response({'status': True}) else: raise PermissionDenied() except KeyError: raise PermissionDenied()
def export_rie_adherent(request): serializer = serializers.ExportRIESerializer(data=request.query_params) serializer.is_valid(raise_exception=True) try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) query_data = [cyclos.user_id, None] accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=query_data) for account in (accounts_summaries_data['result']): if account['number'] == request.query_params['account']: # add loop to context to display rie 6 times context = {'account': account, 'loop': range(0, 3)} response = wkhtmltopdf_views.PDFTemplateResponse( request=request, context=context, template="summary/rie.html") pdf_content = response.rendered_content headers = { 'Content-Disposition': 'filename="pdf_id.pdf"', 'Content-Length': len(pdf_content), } return Response(pdf_content, headers=headers)
def notifier_crediteur(request, mandat, template): """ Envoi d'une notification par email au créditeur. """ # On cherche le créditeur dans Cyclos par son numéro de compte, pour avoir son numéro d'adhérent, puis on # charge les informations de cet adhérent dans Dolibarr et enfin, on lui envoie un email. try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) data = cyclos.post(method='user/search', data={'keywords': mandat.numero_compte_crediteur}) crediteur = data['result']['pageItems'][0] crediteur_dolibarr = dolibarr.get(model='members', sqlfilters="login='******'".format(crediteur['shortDisplay']))[0] # Activation de la langue choisie par l'adhérent et traduction du sujet et du corps de l'email. activate(crediteur_dolibarr['array_options']['options_langue']) subject = _("Compte Eusko : demande d'autorisation de prélèvements") body = render_to_string('mails/{}.txt'.format(template), {'user': crediteur_dolibarr, 'debiteur': mandat.nom_debiteur}) # Envoi de l'email sendmail_euskalmoneta(subject=subject, body=body, to_email=crediteur_dolibarr['email'])
def accounts_summaries(request, login_bdc=None): """ List all accounts_summaries for this BDC user. """ cyclos_mode = 'gi_bdc' if login_bdc else 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode, login_bdc=login_bdc) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # account/getAccountsSummary query_data = [cyclos.user_bdc_id, None] # ID de l'utilisateur Bureau de change accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=query_data) # Stock de billets: stock_de_billets_bdc # Caisse euros: caisse_euro_bdc # Caisse eusko: caisse_eusko_bdc # Retour eusko: retours_d_eusko_bdc res = {} filter_keys = ['stock_de_billets_bdc', 'caisse_euro_bdc', 'caisse_eusko_bdc', 'retours_d_eusko_bdc'] for filter_key in filter_keys: data = [item for item in accounts_summaries_data['result'] if item['type']['id'] == str(settings.CYCLOS_CONSTANTS['account_types'][filter_key])][0] res[filter_key] = {} res[filter_key]['id'] = data['id'] res[filter_key]['balance'] = float(data['status']['balance']) res[filter_key]['currency'] = data['currency']['symbol'] res[filter_key]['type'] = {'name': data['type']['name'], 'id': filter_key} return Response(res)
def change_password(request): """ change_password """ serializer = serializers.ChangePasswordSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: cyclos_mode = request.data['cyclos_mode'] except KeyError: cyclos_mode = 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # password/change change_password_data = { 'user': cyclos.user_id, # ID de l'utilisateur 'type': str(settings.CYCLOS_CONSTANTS['password_types']['login_password']), 'oldPassword': request.data['old_password'], # saisi par l'utilisateur 'newPassword': request.data['new_password'], # saisi par l'utilisateur 'confirmNewPassword': request.data['confirm_password'], # saisi par l'utilisateur } return Response(cyclos.post(method='password/change', data=change_password_data))
def get_current_user_account_number(request): """ Renvoie le numéro de compte de l'utilisateur courant (i.e. l'utilisateur qui a fait la requête). """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=[cyclos.user_id, None]) return accounts_summaries_data['result'][0]['number']
def euskokart_pin(request): try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) response = cyclos.post(method='password/getData', data=cyclos.user_id) pin_code = [ p for p in response['result']['passwords'] if p['type']['id'] == str( settings.CYCLOS_CONSTANTS['password_types']['pin']) ][0] return Response(pin_code['status'])
def account_summary_for_adherents(request): try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) query_data = [cyclos.user_id, None] accounts_summaries_data = cyclos.post(method='account/getAccountsSummary', data=query_data) return Response(accounts_summaries_data)
def change_euro_eusko(request): """ Change d'€ en eusko pour un adhérent via un BDC. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.ChangeEuroEuskoSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) member_cyclos_id = cyclos.get_member_id_from_login(request.data['member_login']) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) dolibarr_member = dolibarr.get(model='members', sqlfilters="login='******'".format(request.data['member_login']))[0] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except IndexError: return Response({'error': 'Unable to fetch Dolibarr data! Maybe your credentials are invalid!?'}, status=status.HTTP_400_BAD_REQUEST) if dolibarr_member['type'].lower() == 'particulier': member_name = '{} {}'.format(dolibarr_member['firstname'], dolibarr_member['lastname']) else: member_name = dolibarr_member['company'] # payment/perform query_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['change_billets_versement_des_euro']), 'amount': request.data['amount'], 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['euro']), 'from': 'SYSTEM', 'to': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id # ID de l'adhérent }, { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['mode_de_paiement']), 'enumeratedValues': request.data['payment_mode'] # ID du mode de paiement (chèque ou espèces) }, ], # "Change - E12345 - Nom de l'adhérent - Mode de paiement" 'description': 'Change billets - {} - {} - {}'.format( request.data['member_login'], member_name, request.data['payment_mode_name']), } return Response(cyclos.post(method='payment/perform', data=query_data))
def euskokart_unblock(request): serializer = serializers.EuskokartLockSerializer(data=request.query_params) serializer.is_valid(raise_exception=True) try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) query_data = [serializer.data['id']] euskokart_data = cyclos.post(method='token/unblock', data=query_data) return Response(euskokart_data)
def deposit_banks_summaries(request): """ Accounts summaries for deposit banks. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='gi_bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # user/search for group = 'Banques de dépot' banks_data = cyclos.post(method='user/search', data={'groups': [settings.CYCLOS_CONSTANTS['groups']['banques_de_depot']]}) bank_names = [{'label': item['display'], 'value': item['id'], 'shortLabel': item['shortDisplay']} for item in banks_data['result']['pageItems']] res = {} for bank in bank_names: bank_user_query = { 'keywords': bank['shortLabel'], # shortLabel = shortDisplay from Cyclos } try: bank_user_data = cyclos.post(method='user/search', data=bank_user_query)['result']['pageItems'][0] bank_account_query = [bank_user_data['id'], None] bank_data = cyclos.post(method='account/getAccountsSummary', data=bank_account_query)['result'][0] except (KeyError, IndexError): return Response({'error': 'Unable to get bank data for one of the depositbank!'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) res[bank['shortLabel']] = bank res[bank['shortLabel']]['balance'] = float(bank_data['status']['balance']) res[bank['shortLabel']]['currency'] = bank_data['currency']['symbol'] res[bank['shortLabel']]['type'] = {'name': bank_data['type']['name'], 'id': bank_data['type']['id']} return Response(res)
def reconversion(request): """ Reconversion eusko en euros pour un adhérent (prestataire) via un BDC. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.ReconversionSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) dolibarr_member = dolibarr.get(model='members', sqlfilters="login='******'".format(request.data['member_login']))[0] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except IndexError: return Response({'error': 'Unable to fetch Dolibarr data! Maybe your credentials are invalid!?'}, status=status.HTTP_400_BAD_REQUEST) if dolibarr_member['type'].lower() == 'particulier': return Response({'error': 'Forbidden, reconversion is not available for non-business members!'}, status=status.HTTP_403_FORBIDDEN) member_cyclos_id = cyclos.get_member_id_from_login(request.data['member_login']) # payment/perform query_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['reconversion_billets_versement_des_eusko']), 'amount': request.data['amount'], 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': 'SYSTEM', 'to': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id # ID de l'adhérent }, { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['numero_de_facture']), 'stringValue': request.data['facture'] # ID Facture }, ], 'description': 'Reconversion - {} - {}'.format(request.data['member_login'], dolibarr_member['company']), } return Response(cyclos.post(method='payment/perform', data=query_data))
def payments_available_for_entree_stock(request): """ payments_available_for_entree_stock """ serializer = serializers.PaymentsAvailableEntreeStockSerializer(data=request.query_params) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: login_bdc = request.query_params['login_bdc'] cyclos_mode = 'gi_bdc' except KeyError: login_bdc = None cyclos_mode = 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode, login_bdc=login_bdc) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # account/searchAccountHistory search_history_data = { 'account': str(settings.CYCLOS_CONSTANTS['system_accounts']['compte_de_transit']), 'orderBy': 'DATE_DESC', 'direction': 'CREDIT', 'fromNature': 'SYSTEM', 'statuses': [ str(settings.CYCLOS_CONSTANTS['transfer_statuses']['a_rapprocher']) ], 'pageSize': 1000, # maximum pageSize: 1000 'currentPage': 0, } accounts_summaries_res = cyclos.post(method='account/searchAccountHistory', data=search_history_data) # Filter out the results that are not "Sortie coffre" and items that are not for this BDC accounts_summaries_data = [ item for item in accounts_summaries_res['result']['pageItems'] for value in item['customValues'] if item['type']['id'] == str(settings.CYCLOS_CONSTANTS['payment_types']['sortie_coffre']) and value['field']['internalName'] == 'bdc' and value['linkedEntityValue']['id'] == cyclos.user_bdc_id ] return Response(accounts_summaries_data)
def euskokart_list(request): try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) query_data = [ str(settings.CYCLOS_CONSTANTS['tokens']['carte_nfc']), cyclos.user_id ] euskokart_data = cyclos.post(method='token/getListData', data=query_data) try: euskokart_res = [item for item in euskokart_data['result']['tokens']] except KeyError: return Response({'error': 'Unable to fetch euskokart data!'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) return Response(euskokart_res)
def create(self, request, *args, **kwargs): """ Créer un bénéficiaire en donnant son numéro de compte. """ serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) cyclos_account_number = serializer.validated_data[ 'cyclos_account_number'] # Si ce bénéficiaire existe déjà, on renvoie simplement OK. try: beneficiaire = Beneficiaire.objects.get( owner=self.request.user, cyclos_account_number=cyclos_account_number) if beneficiaire: serializer = self.get_serializer(beneficiaire) return Response(serializer.data, status=status.HTTP_200_OK) except Beneficiaire.DoesNotExist: pass # Le bénéficiaire n'existe pas, on va le créer. # On cherche dans Cyclos l'utilisateur correspondant au numéro de compte du bénéficiaire à créer. try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) data = cyclos.post(method='user/search', data={'keywords': cyclos_account_number}) if data['result']['totalCount'] == 0: return Response({'error': _("Ce numéro de compte n'existe pas")}, status=status.HTTP_422_UNPROCESSABLE_ENTITY) cyclos_user = data['result']['pageItems'][0] # Enregistrement du bénéficiaire en base de données. beneficiaire = serializer.save(owner=str(request.user), cyclos_id=cyclos_user['id'], cyclos_name=cyclos_user['display']) # Le bénéficiaire créé est envoyé dans la réponse. serializer = self.get_serializer(beneficiaire) return Response(serializer.data, status=status.HTTP_201_CREATED)
def porteurs_eusko(request): """ List porteurs d'euskos. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # user/search for group = 'Porteurs' porteurs_data = cyclos.post( method='user/search', data={'groups': [settings.CYCLOS_CONSTANTS['groups']['porteurs']]}) res = [{ 'label': item['display'], 'value': item['id'] } for item in porteurs_data['result']['pageItems']] return Response(res)
def sortie_stock(request): """ Enregistre une sortie dans le stock billets d'un BDC. """ serializer = serializers.SortieStockBDCSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: login_bdc = request.data['login_bdc'] cyclos_mode = 'gi_bdc' except KeyError: login_bdc = None cyclos_mode = 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode, login_bdc=login_bdc) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # payment/perform query_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['sortie_stock_bdc']), 'amount': request.data['amount'], 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'to': 'SYSTEM', 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['porteur']), 'linkedEntityValue': request.data['porteur'] # ID du porteur }, ], 'description': request.data['description'], } return Response(cyclos.post(method='payment/perform', data=query_data))
def deposit_banks(request): """ List available banks. """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # user/search for group = 'Banques de dépot' banks_data = cyclos.post( method='user/search', data={ 'groups': [settings.CYCLOS_CONSTANTS['groups']['banques_de_depot']] }) res = [{ 'label': item['display'], 'value': item['id'], 'shortLabel': item['shortDisplay'] } for item in banks_data['result']['pageItems']] return Response(res)
def search(self, request, *args, **kwargs): query = request.query_params.get('number', False) res = None if not query or len(query) != 9: return exceptions.ParseError() try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='cel') # user/search by account number only data = cyclos.post( method='user/search', data={'keywords': str(request.query_params['number'])}) res = [{ 'label': item['display'], 'id': item['id'] } for item in data['result']['pageItems']][0] except (KeyError, IndexError, CyclosAPIException): Response(status=status.HTTP_204_NO_CONTENT) return Response(res) if res else Response( status=status.HTTP_204_NO_CONTENT)
class MembersAPIView(BaseAPIView): def __init__(self, **kwargs): super(MembersAPIView, self).__init__(model='members') def create(self, request): data = request.data serializer = MemberSerializer(data=data) if serializer.is_valid(): data = Member.validate_data(data) else: log.critical(serializer.errors) return Response({'error': 'Oops! Something is wrong in your request data: {}'.format(serializer.errors)}, status=status.HTTP_400_BAD_REQUEST) log.info('posted data: {}'.format(data)) # #841 : We need to connect to Cyclos before doing Dolibarr calls, making sure Cyclos token is still valid. # This way, we avoid creating a member in Dolibarr if it's not the case. try: self.cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) # Dolibarr: Register member response_obj = self.dolibarr.post(model=self.model, data=data, api_key=request.user.profile.dolibarr_token) log.info(response_obj) # Cyclos: Register member create_user_data = { 'group': str(settings.CYCLOS_CONSTANTS['groups']['adherents_sans_compte']), 'name': '{} {}'.format(data['firstname'], data['lastname']), 'username': data['login'], 'skipActivationEmail': True, } self.cyclos.post(method='user/register', data=create_user_data) return Response(response_obj, status=status.HTTP_201_CREATED) def list(self, request): email = request.GET.get('email', '') login = request.GET.get('login', '') name = request.GET.get('name', '') valid_login = Member.validate_num_adherent(login) token = request.GET.get('token', '') # Si un token est fourni pour récupérer un adhérent, la # recherche peut être faite de manière anonyme, sinon il faut # être authentifié, afin d'éviter la fuite d'information sur les # adhérents. if token and not request.user.is_authenticated: dolibarr = DolibarrAPI() dolibarr_token = dolibarr.login(login=settings.APPS_ANONYMOUS_LOGIN, password=settings.APPS_ANONYMOUS_PASSWORD) else: dolibarr_token = request.user.profile.dolibarr_token if login and valid_login: # We want to search in members by login (N° Adhérent) try: response = self.dolibarr.get(model='members', sqlfilters="login='******'".format(login), api_key=dolibarr_token) except DolibarrAPIException: return Response(status=status.HTTP_204_NO_CONTENT) return Response(response) elif login and not valid_login: return Response({'error': 'You need to provide a *VALID* ?login parameter! (Format: E12345)'}, status=status.HTTP_400_BAD_REQUEST) elif name and len(name) >= 3: # We want to search in members by name (firstname, lastname or societe) try: sqlfilters = "(firstname like '%25{name}%25' or lastname like '%25{name}%25' or societe like '%25{name}%25') and statut=1".format(name=name) response = self.dolibarr.get(model='members', sqlfilters=sqlfilters, api_key=dolibarr_token) except DolibarrAPIException: return Response(status=status.HTTP_204_NO_CONTENT) return Response(response) elif name and len(name) < 3: return Response({'error': 'You need to provide a ?name parameter longer than 2 characters!'}, status=status.HTTP_400_BAD_REQUEST) elif email: try: validate_email(email) user_results = self.dolibarr.get(model='members', sqlfilters="email='{}' and statut=1".format(email), api_key=dolibarr_token) user_data = [item for item in user_results if item['email'] == email][0] return Response(user_data) except forms.ValidationError: return Response({'error': 'You need to provide a *VALID* ?email parameter! (Format: E12345)'}, status=status.HTTP_400_BAD_REQUEST) elif token: try: response = self.dolibarr.get(model='members', token=token, api_key=dolibarr_token) except DolibarrAPIException: return Response(status=status.HTTP_204_NO_CONTENT) return Response(response) else: objects = self.dolibarr.get(model='members', sqlfilters="statut=1", api_key=dolibarr_token) paginator = CustomPagination() result_page = paginator.paginate_queryset(objects, request) serializer = MemberSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data) def update(self, request, pk=None): # return Response(self.dolibarr.patch(model=self.model, api_key=dolibarr_token)) pass def partial_update(self, request, pk=None): serializer = MemberPartialSerializer(data=request.data) if serializer.is_valid(): member = self.dolibarr.get(model='members/{}'.format(pk), api_key=request.user.profile.dolibarr_token) # Validate / modify data (serialize to match Dolibarr formats) data = Member.validate_data(request.data, mode='update', base_options=member['array_options']) try: # Envoi d'un email lorsque l'option "Recevoir les actualités liées à l'Eusko" est modifiée if (member['array_options']['options_recevoir_actus'] != data['array_options']['options_recevoir_actus']): Member.send_mail_newsletter( login=str(request.user), profile=request.user.profile, new_status=data['array_options']['options_recevoir_actus'], lang=member['array_options']['options_langue']) # Envoi d'un email lorsque l'option "Montant du change automatique" est modifiée if (float(member['array_options']['options_prelevement_change_montant']) != float(data['array_options']['options_prelevement_change_montant'])): Member.send_mail_change_auto( login=str(request.user), profile=request.user.profile, mode=data['mode'], new_amount=data['array_options']['options_prelevement_change_montant'], comment=data['prelevement_change_comment'], email=member['email'], lang=member['array_options']['options_langue']) # Envoi d'un email lorsque l'option "IBAN" est modifiée. if (member['array_options']['options_iban'] != data['array_options']['options_iban']): sujet = _("Modification de l'IBAN pour le change automatique mensuel") texte = render_to_string('mails/modification_iban.txt', {'dolibarr_member': member, 'nouvel_iban': data['array_options']['options_iban']}).strip('\n') sendmail_euskalmoneta(subject=sujet, body=texte) except KeyError: pass else: log.critical(serializer.errors) return Response({'error': 'Oops! Something is wrong in your request data: {}'.format(serializer.errors)}, status=status.HTTP_400_BAD_REQUEST) return Response(self.dolibarr.put(model='members/{}'.format(pk), data=data, api_key=request.user.profile.dolibarr_token))
class MembersSubscriptionsAPIView(BaseAPIView): def __init__(self, **kwargs): super(MembersSubscriptionsAPIView, self).__init__(model='members/%_%/subscriptions') def create(self, request): data = request.data dolibarr_token = request.user.profile.dolibarr_token log.info("data: {}".format(data)) serializer = MembersSubscriptionsSerializer(data=data) if not serializer.is_valid(): log.critical("serializer.errors: {}".format(serializer.errors)) return Response({'error': 'Oops! Something is wrong in your request data: {}'.format(serializer.errors)}, status=status.HTTP_400_BAD_REQUEST) member_id = data.get('member_id', '') if not member_id: log.critical('A member_id must be provided!') return Response({'error': 'A member_id must be provided!'}, status=status.HTTP_400_BAD_REQUEST) # #841 : We need to connect to Cyclos before doing Dolibarr calls, making sure Cyclos token is still valid. # This way, we avoid creating a subscription in Dolibarr if it's not the case. try: self.cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) try: member = self.dolibarr.get(model='members', id=member_id, api_key=dolibarr_token) except DolibarrAPIException as e: log.critical("member_id: {}".format(member_id)) log.critical(e) log.critical('This member_id was not found in the database!') return Response({'error': 'This member_id was not found in the database!'}, status=status.HTTP_400_BAD_REQUEST) data['start_date'] = Subscription.calculate_start_date(member['datefin']) data['end_date'] = Subscription.calculate_end_date(data['start_date']) data['label'] = Subscription.calculate_label(data['end_date']) log.info("data after: {}".format(data)) # Register new subscription data_res_subscription = {'start_date': data['start_date'], 'end_date': data['end_date'], 'amount': data['amount'], 'label': data['label']} self.model = self.model.replace('%_%', member_id) try: res_id_subscription = self.dolibarr.post( model=self.model, data=data_res_subscription, api_key=dolibarr_token) log.info("res_id_subscription: {}".format(res_id_subscription)) except DolibarrAPIException as e: log.critical("model: {}".format(self.model)) log.critical("data_res_subscription: {}".format(data_res_subscription)) log.critical(e) return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST) # Register new payment payment_account, payment_type, payment_label = Subscription.account_and_type_from_payment_mode(data['payment_mode']) # noqa if not payment_account or not payment_type: log.critical('This payment_mode is invalid!') return Response({'error': 'This payment_mode is invalid!'}, status=status.HTTP_400_BAD_REQUEST) data_res_payment = {'date': arrow.now('Europe/Paris').timestamp, 'type': payment_type, 'label': data['label'], 'amount': data['amount']} model_res_payment = 'bankaccounts/{}/lines'.format(payment_account) try: res_id_payment = self.dolibarr.post( model=model_res_payment, data=data_res_payment, api_key=dolibarr_token) log.info("res_id_payment: {}".format(res_id_payment)) except DolibarrAPIException as e: log.critical("model: {}".format(model_res_payment)) log.critical("data_res_payment: {}".format(data_res_payment)) log.critical(e) return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST) # Link this new subscription with this new payment data_link_sub_payment = {'fk_bank': res_id_payment} model_link_sub_payment = 'subscriptions/{}'.format(res_id_subscription) try: res_id_link_sub_payment = self.dolibarr.put( model=model_link_sub_payment, data=data_link_sub_payment, api_key=dolibarr_token) log.info("res_id_link_sub_payment: {}".format(res_id_link_sub_payment)) except DolibarrAPIException as e: log.critical("model: {}".format(model_link_sub_payment)) log.critical("data_link_sub_payment: {}".format(data_link_sub_payment)) log.critical(e) return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST) # Link this payment with the related-member data_link_payment_member = {'label': '{} {}'.format(member['firstname'], member['lastname']), 'type': 'member', 'url_id': member_id, 'url': '{}/adherents/card.php?rowid={}'.format( settings.DOLIBARR_PUBLIC_URL, member_id)} model_link_payment_member = 'bankaccounts/{}/lines/{}/links'.format(payment_account, res_id_payment) try: res_id_link_payment_member = self.dolibarr.post( model=model_link_payment_member, data=data_link_payment_member, api_key=dolibarr_token) log.info("res_id_link_payment_member: {}".format(res_id_link_payment_member)) except DolibarrAPIException as e: log.critical("model: {}".format(model_link_payment_member)) log.critical("data_link_payment_member: {}".format(data_link_payment_member)) log.critical(e) return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST) current_member = self.dolibarr.get(model='members', id=member_id, api_key=dolibarr_token) res = {'id_subscription': res_id_subscription, 'id_payment': res_id_payment, 'link_sub_payment': res_id_link_sub_payment, 'id_link_payment_member': res_id_link_payment_member, 'member': current_member} if current_member['type'].lower() in ('particulier', 'touriste'): member_name = '{} {}'.format(current_member['firstname'], current_member['lastname']) else: member_name = current_member['company'] # Get Cyclos member and create it if it does not exist. try: member_cyclos_id = self.cyclos.get_member_id_from_login(current_member['login']) except CyclosAPIException: log.debug("Member not found in Cyclos, will create it.") create_user_data = { 'group': str(settings.CYCLOS_CONSTANTS['groups']['adherents_sans_compte']), 'name': '{} {}'.format(current_member['firstname'], current_member['lastname']), 'username': current_member['login'], 'skipActivationEmail': True, } log.debug("create_user_data = {}".format(create_user_data)) response_data = self.cyclos.post(method='user/register', data=create_user_data) member_cyclos_id = response_data['result']['user']['id'] log.debug("member_cyclos_id = {}".format(member_cyclos_id)) # Cyclos: Register member subscription payment query_data = {} if 'Eusko' in data['payment_mode']: query_data.update( {'type': str(settings.CYCLOS_CONSTANTS['payment_types']['cotisation_en_eusko']), 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'customValues': [ {'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id}], 'description': 'Cotisation - {} - {}'.format( current_member['login'], member_name), }) currency = 'eusko' elif 'Euro' in data['payment_mode']: query_data.update( {'type': str(settings.CYCLOS_CONSTANTS['payment_types']['cotisation_en_euro']), 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['euro']), 'customValues': [ {'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id}, {'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['mode_de_paiement']), 'enumeratedValues': data['cyclos_id_payment_mode']}], 'description': 'Cotisation - {} - {} - {}'.format( current_member['login'], member_name, payment_label), }) currency = '€' else: return Response({'error': 'This payment_mode is invalid!'}, status=status.HTTP_400_BAD_REQUEST) query_data.update({ 'amount': data['amount'], 'from': 'SYSTEM', 'to': self.cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change }) self.cyclos.post(method='payment/perform', data=query_data) return Response(res, status=status.HTTP_201_CREATED) def update(self, request, pk=None): pass def partial_update(self, request, pk=None): pass def destroy(self, request, pk): pass
def retrait_eusko_numerique(request): """ Retrait eusko: numerique vers billets """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.RetraitEuskoNumeriqueSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) member_cyclos_id = cyclos.get_member_id_from_login(request.data['member_login']) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) dolibarr_member = dolibarr.get(model='members', sqlfilters="login='******'".format(request.data['member_login']))[0] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except IndexError: return Response({'error': 'Unable to fetch Dolibarr data! Maybe your credentials are invalid!?'}, status=status.HTTP_400_BAD_REQUEST) if dolibarr_member['type'].lower() == 'particulier': member_name = '{} {}'.format(dolibarr_member['firstname'], dolibarr_member['lastname']) else: member_name = dolibarr_member['company'] # Verify whether or not member account has enough money member_account_summary_query = [member_cyclos_id, None] # ID de l'adhérent member_account_summary_res = cyclos.post(method='account/getAccountsSummary', data=member_account_summary_query) try: if (member_account_summary_res['result'][0]['type']['id'] != str(settings.CYCLOS_CONSTANTS['account_types']['compte_d_adherent'])): return Response({'error': "Unable to fetch account data!"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) except (KeyError, IndexError): return Response({'error': "Unable to fetch account data!"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) try: if float(member_account_summary_res['result'][0]['status']['balance']) < float(request.data['amount']): return Response({'error': "error-member-not-enough-money"}) except (KeyError, IndexError): return Response({'error': "Unable to fetch account data!"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) # Verify whether or not bdc cash stock have enough money bdc_account_summary_query = [cyclos.user_bdc_id, None] # ID de l'utilisateur Bureau de change bdc_account_summary_res = cyclos.post(method='account/getAccountsSummary', data=bdc_account_summary_query) bdc_account_summary_data = [ item for item in bdc_account_summary_res['result'] if item['type']['id'] == str(settings.CYCLOS_CONSTANTS['account_types']['stock_de_billets_bdc'])][0] if float(bdc_account_summary_data['status']['balance']) < float(request.data['amount']): return Response({'error': "error-bureau-not-enough-money"}) # Débit du compte debit_compte_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['retrait_du_compte']), 'amount': request.data['amount'], # montant saisi 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': member_cyclos_id, # ID de l'adhérent 'to': 'SYSTEM', 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['bdc']), 'linkedEntityValue': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change }, ], 'description': 'Retrait', } cyclos.post(method='payment/perform', data=debit_compte_data) # Retrait des billets retrait_billets_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['retrait_de_billets']), 'amount': request.data['amount'], # montant saisi 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'to': 'SYSTEM', 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id, # ID de l'adhérent }, ], 'description': 'Retrait - {} - {}'.format(request.data['member_login'], member_name), } cyclos.post(method='payment/perform', data=retrait_billets_data) return Response(retrait_billets_data)
def depot_eusko_numerique(request): """ depot-eusko-numerique """ try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode='bdc') except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) serializer = serializers.DepotEuskoNumeriqueSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) member_cyclos_id = cyclos.get_member_id_from_login(request.data['member_login']) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) dolibarr_member = dolibarr.get(model='members', sqlfilters="login='******'".format(request.data['member_login']))[0] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except IndexError: return Response({'error': 'Unable to fetch Dolibarr data! Maybe your credentials are invalid!?'}, status=status.HTTP_400_BAD_REQUEST) if dolibarr_member['type'].lower() == 'particulier': member_name = '{} {}'.format(dolibarr_member['firstname'], dolibarr_member['lastname']) else: member_name = dolibarr_member['company'] # Retour des Eusko billets retour_eusko_billets_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['depot_de_billets']), 'amount': request.data['amount'], # montant saisi 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': 'SYSTEM', 'to': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': member_cyclos_id # ID de l'adhérent }, ], 'description': 'Dépôt - {} - {}'.format(request.data['member_login'], member_name), } cyclos.post(method='payment/perform', data=retour_eusko_billets_data) # Crédit du compte Eusko numérique du prestataire depot_eusko_numerique_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['credit_du_compte']), 'amount': request.data['amount'], # montant saisi 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': 'SYSTEM', 'to': member_cyclos_id, # ID de l'adhérent 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['bdc']), 'linkedEntityValue': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change }, ], 'description': 'Dépôt', } cyclos.post(method='payment/perform', data=depot_eusko_numerique_data) return Response(depot_eusko_numerique_data)
def sortie_retour_eusko(request): """ sortie_retour_eusko """ serializer = serializers.SortieRetourEuskoSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: login_bdc = request.data['login_bdc'] cyclos_mode = 'gi_bdc' except KeyError: login_bdc = None cyclos_mode = 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode, login_bdc=login_bdc) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) bdc_code = request.data['login_bdc'] bdc_name = dolibarr.get(model='users', sqlfilters="login='******'".format(bdc_code))[0]['lastname'] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except (IndexError, KeyError): return Response({'error': 'Unable to get user data from your user!'}, status=status.HTTP_400_BAD_REQUEST) for payment in request.data['selected_payments']: try: adherent_id = [ value['linkedEntityValue']['id'] for value in payment['customValues'] if value['field']['id'] == str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']) and value['field']['internalName'] == 'adherent' ][0] except (KeyError, IndexError): return Response({'error': 'Unable to get adherent_id from one of your selected_payments!'}, status=status.HTTP_400_BAD_REQUEST) # Enregistrer les retours d'eusko sortie_retour_eusko_data = { 'type': str(settings.CYCLOS_CONSTANTS['payment_types']['sortie_retours_eusko_bdc']), 'amount': payment['amount'], # montant de l'opération correspondante 'currency': str(settings.CYCLOS_CONSTANTS['currencies']['eusko']), 'from': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'to': 'SYSTEM', # System account 'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['adherent']), 'linkedEntityValue': adherent_id, # ID de l'adhérent }, { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['porteur']), 'linkedEntityValue': request.data['porteur'] # ID du porteur }, ], # "Sortie retour d'eusko - Bxxx - Nom du BDC # Opération de Z12345 - Nom du prestataire" -> description du payment initial 'description': 'Sortie retours eusko - {} - {}\n{}'.format( bdc_code, bdc_name, payment['description']) } cyclos.post(method='payment/perform', data=sortie_retour_eusko_data) # Passer tous les paiements à l'origine du dépôt à l'état "Remis à Euskal Moneta" transfer_change_status_data = { 'transfer': payment['id'], # ID du paiement (récupéré dans l'historique) 'newStatus': str(settings.CYCLOS_CONSTANTS['transfer_statuses']['remis_a_euskal_moneta']) } cyclos.post(method='transferStatus/changeStatus', data=transfer_change_status_data) return Response(request.data)
def cash_deposit(request): """ cash_deposit """ serializer = serializers.CashDepositSerializer(data=request.data) serializer.is_valid(raise_exception=True) # log.critical(serializer.errors) try: login_bdc = request.data['login_bdc'] cyclos_mode = 'gi_bdc' except KeyError: login_bdc = None cyclos_mode = 'bdc' try: cyclos = CyclosAPI(token=request.user.profile.cyclos_token, mode=cyclos_mode, login_bdc=login_bdc) except CyclosAPIException: return Response({'error': 'Unable to connect to Cyclos!'}, status=status.HTTP_400_BAD_REQUEST) try: dolibarr = DolibarrAPI(api_key=request.user.profile.dolibarr_token) bdc_code = request.data['login_bdc'] bdc_name = dolibarr.get(model='users', sqlfilters="login='******'".format(bdc_code))[0]['lastname'] except DolibarrAPIException: return Response({'error': 'Unable to connect to Dolibarr!'}, status=status.HTTP_400_BAD_REQUEST) except (IndexError, KeyError): return Response({'error': 'Unable to get user data from your user!'}, status=status.HTTP_400_BAD_REQUEST) if request.data['mode'] == 'cash-deposit': payment_type = str(settings.CYCLOS_CONSTANTS['payment_types']['remise_d_euro_en_caisse']) currency = str(settings.CYCLOS_CONSTANTS['currencies']['euro']) description = "Remise d'espèces - {} - {}".format(bdc_code, bdc_name) elif request.data['mode'] == 'sortie-caisse-eusko': try: porteur = request.data['porteur'] except KeyError: return Response({'error': 'Porteur parameter is incorrect!'}, status=status.HTTP_400_BAD_REQUEST) payment_type = str(settings.CYCLOS_CONSTANTS['payment_types']['sortie_caisse_eusko_bdc']) currency = str(settings.CYCLOS_CONSTANTS['currencies']['eusko']) description = 'Sortie caisse eusko - {} - {}'.format(bdc_code, bdc_name) else: return Response({'error': 'Mode parameter is incorrect!'}, status=status.HTTP_400_BAD_REQUEST) # Enregistrer la remise d'espèces cash_deposit_data = { 'type': payment_type, 'amount': request.data['deposit_amount'], # montant total calculé 'currency': currency, 'from': cyclos.user_bdc_id, # ID de l'utilisateur Bureau de change 'to': 'SYSTEM', # System account 'description': description } if request.data['mode'] == 'sortie-caisse-eusko': cash_deposit_data.update({'customValues': [ { 'field': str(settings.CYCLOS_CONSTANTS['transaction_custom_fields']['porteur']), 'linkedEntityValue': porteur # ID du porteur }, ]}) cyclos.post(method='payment/perform', data=cash_deposit_data) for payment in request.data['selected_payments']: # Passer tous les paiements à l'origine du dépôt à l'état "Remis à Euskal Moneta" transfer_change_status_data = { 'transfer': payment['id'], # ID du paiement (récupéré dans l'historique) 'newStatus': str(settings.CYCLOS_CONSTANTS['transfer_statuses']['remis_a_euskal_moneta']) } cyclos.post(method='transferStatus/changeStatus', data=transfer_change_status_data) return Response(cash_deposit_data)