Example #1
0
 def POST(self):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     x = web.input(file={})
     return_json = json.dumps(rep_gen.generate_ordinary_earnings_report(thread_dao, x.file.file))
     kill_thread_db_session(thread_dao)
     return return_json
Example #2
0
 def POST(self):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     offers = map(lambda x: x.as_dictionary, thread_dao.retrieve_all_offers())
     return_json = json.dumps(offers)
     kill_thread_db_session(thread_dao)
     return return_json
Example #3
0
 def POST(self):
     thread_dao = dao(engine=engine)
     try:
         thread_dao.full_back_up()
         return_text = 'ok'
     except Exception, e:
         return_text ='Error al generar el back up: {0}'.format(e.message)
Example #4
0
 def POST(self):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     return_json = json.dumps(map(lambda x: x.as_dictionary(payments_data=False),
                                  thread_dao.retrieve_all_offers(payments_data=False)))
     kill_thread_db_session(thread_dao)
     return return_json
Example #5
0
 def DELETE(self):
     parameters = json.loads(web.data())
     thread_dao = dao(engine=engine)
     try:
         thread_dao.drop_back_up(parameters['timestamp_string'])
         return_text = 'ok'
     except Exception, e:
         return_text = 'Error: {0} - {1}'.format(e.__class__.__name__, e.message)
Example #6
0
 def POST(self):
     parameters = json.loads(web.data())
     thread_dao = dao(engine=engine)
     try:
         thread_dao.recover_back_up(parameters['timestamp_string'],
                                    back_up_current_data=parameters['back_up_current_data'])
         return_text = 'ok'
     except Exception, e:
         return_text = 'Error: {0} - {1}'.format(e.__class__.__name__, e.message)
Example #7
0
 def POST(self, offer_id):
     thread_dao = dao()
     try:
         thread_dao.delete_offer_by_id(offer_id)
         thread_dao.persist_changes()
         kill_thread_db_session(thread_dao)
         return 'ok'
     except Exception, e:
         kill_thread_db_session(thread_dao)
         return 'Error al eliminar la oferta{0}: {1}'.format(offer_id, e.message)
Example #8
0
 def POST(self):
     thread_dao = dao()
     try:
         offer_dict = json.loads(web.data())
         thread_dao.delete_offer_by_id(offer_dict['id'])
         thread_dao.create_offer_from_dictionary(offer_dict)
         thread_dao.persist_changes()
         kill_thread_db_session(thread_dao)
         return 'ok'
     except Exception, e:
         kill_thread_db_session(thread_dao)
         return 'Error al guardar la oferta: {0}'.format(e.message)
Example #9
0
 def POST(self, supplier_id):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     supplier = thread_dao.retrieve_supplier_by_id(int(supplier_id))
     if supplier.__class__.__name__ == 'Supplier':
         result_json = json.dumps(supplier.as_dictionary)
     else:
         supplier = Supplier(0, '', PaymentTypeWeeklyExchanges())
         PaymentMethod(supplier, '', '')
         result_json = json.dumps(supplier.as_dictionary)
     kill_thread_db_session(thread_dao)
     return result_json
Example #10
0
    def POST(self):
        web.header('Content-Type', 'application/json')
        thread_dao = dao(engine=engine)
        x = web.input(file={})
        if 'input-generate-back-up-checkbox' in web.input().keys():
            thread_dao.full_back_up()

        return_json = json.dumps(imp_file.parse_file(thread_dao, x.file.file,
                                                     persist_results=(not 'input-dont-load-contents-checkbox'
                                                                          in web.input().keys())))
        kill_thread_db_session(thread_dao)
        return return_json
Example #11
0
 def POST(self):
     try:
         thread_dao = dao()
         offers = thread_dao.retrieve_all_offers(payments_data=False)
         changes = json.loads(web.data())
         for offer_id in changes.keys():
             offer = filter(lambda x: x.id == int(offer_id), offers)[0]
             offer.include_in_payments_report = changes[offer_id]['include_in_payments_report']
         thread_dao.persist_changes()
         kill_thread_db_session(thread_dao)
         return 'ok'
     except Exception, e:
         return e.__class__.__name__ + ' - ' + e.message
Example #12
0
 def POST(self, supplier_id):
     thread_dao = dao()
     try:
         save_with_warnings = web.data() == 'true'
         warnings = thread_dao.delete_supplier_by_id(supplier_id)
         if warnings == '' or save_with_warnings:
             thread_dao.persist_changes()
             warnings = ''
         kill_thread_db_session(thread_dao)
         return 'ok-{0}'.format(warnings)
     except Exception, e:
         kill_thread_db_session(thread_dao)
         return 'Error al eliminar el proveedor{0}: {1}'.format(supplier_id, e.message)
Example #13
0
 def POST(self):
     thread_dao = dao()
     try:
         supplier_dict = json.loads(web.data())
         warnings = thread_dao.create_supplier_from_dictionary(supplier_dict)
         if warnings == '' or supplier_dict['save_with_warnings']:
             thread_dao.persist_changes()
             warnings = ''
         kill_thread_db_session(thread_dao)
         return 'ok-{0}'.format(warnings)
     except Exception, e:
         kill_thread_db_session(thread_dao)
         return 'Error al guardar el proveedor: {0}'.format(e.message)
Example #14
0
 def POST(self, offer_id):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     offer = thread_dao.retrieve_offer_by_id(int(offer_id))
     if offer is not None:
         return_json = json.dumps(offer.as_dictionary(payments_data=True))
     else:
         supplier = thread_dao.retrieve_first_supplier
         offer = Offer(0, '', supplier, date.today(), None, None, PaymentTypeWeeklyExchanges(),
                       supplier.payment_methods[0], '', True, True)
         SubOffer(offer, 1, 0, 0, 0, 0, 0)
         return_json = json.dumps(offer.as_dictionary(payments_data=True))
     kill_thread_db_session(thread_dao)
     return return_json
Example #15
0
    def PUT(self):
        web.header('Content-Type', 'application/json')
        thread_dao = dao()
        try:
            offers = thread_dao.retrieve_all_offers()
            payments_data = json.loads(web.data())

            for payment in payments_data:
                offer = filter(lambda x: x.id == int(payment['payment'].split('-')[0]), offers)[0]
                sub_offer = filter(lambda x: x.id == int(payment['payment'].split('-')[1]), offer.sub_offers)[0]
                Payment(sub_offer, original_amount=float(payment['amount']), amount=0.0,
                        date=datetime.strptime(payment['date'], '%Y-%m-%d').date(), description=payment['description'],
                        status='Realizado')

            thread_dao.persist_changes()
            kill_thread_db_session(thread_dao)
            return json.dumps({'status': 'ok'})
        except Exception, e:
            kill_thread_db_session(thread_dao)
            return json.dumps({'status': 'error', 'error_class': e.__class__.__name__, 'error_message': e.message})
Example #16
0
 def POST(self):
     try:
         web.header('Content-Type', 'application/json')
         filters = json.loads(web.data()) if web.data() != '' else None
         thread_dao = dao()
         all_offers = thread_dao.retrieve_all_offers()
         all_sub_offers = reduce(lambda sub_offers, offer: sub_offers + offer.sub_offers, all_offers, [])
         calculated_payments = reduce(lambda payments, sub_offer: payments +
                                                                  filter(lambda p: p.status != 'Realizado',
                                                                         sub_offer.calculate_payments),
                                      all_sub_offers, [])
         calculated_payments_dicts = map(lambda payment: dict(payment.as_dictionary,
                                                              **{'sub_offer': payment.sub_offer.as_dictionary(),
                                                                 'offer': payment.sub_offer.offer.as_dictionary()}),
                                         filter(lambda cp: cp.filter(filters), calculated_payments))
         return_json = json.dumps(sorted(calculated_payments_dicts, key=lambda p: p['date'])[:30])
         kill_thread_db_session(thread_dao)
         return return_json
     except Exception, e:
         kill_thread_db_session(thread_dao)
         return '["{0} - {1}"]'.format(str(e.__class__.__name__), str(e.message if e.message is not None else ''))
Example #17
0
    def POST(self):
        web.header('Content-Type', 'application/json')
        parameters = json.loads(web.data())

        if 'date_from' not in parameters.keys():
            date_from = None
        else:
            date_from = date(int(parameters['date_from'].split('-')[0]),
                                      int(parameters['date_from'].split('-')[1]),
                                      int(parameters['date_from'].split('-')[2]))

        if 'date_to' not in parameters.keys():
            date_to = None
        else:
            date_to = date(int(parameters['date_to'].split('-')[0]), int(parameters['date_to'].split('-')[1]),
                                    int(parameters['date_to'].split('-')[2]))

        thread_dao = dao()
        return_json = json.dumps(rep_gen.generate_extraordinary_earnings_report(thread_dao, date_from=date_from,
                                                                                date_to=date_to))
        kill_thread_db_session(thread_dao)
        return return_json
Example #18
0
    def POST(self):
        web.header('Content-Type', 'application/json')
        parameters = json.loads(web.data())

        thread_dao = dao()
        suppliers = filter(lambda x: x.id in map(lambda y: int(y), parameters['suppliers']),
                           thread_dao.retrieve_all_suppliers)

        if 'date_from' not in parameters.keys():
            date_from = None
        else:
            date_from = date(int(parameters['date_from'].split('-')[0]),
                                      int(parameters['date_from'].split('-')[1]),
                                      int(parameters['date_from'].split('-')[2]))

        if 'date_to' not in parameters.keys():
            date_to = None
        else:
            date_to = date(int(parameters['date_to'].split('-')[0]), int(parameters['date_to'].split('-')[1]),
                                    int(parameters['date_to'].split('-')[2]))

        return_json = json.dumps(rep_gen.generate_suppliers_payments_report(thread_dao, suppliers, date_from, date_to))
        kill_thread_db_session(thread_dao)
        return return_json
Example #19
0
 def POST(self):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     return_json = json.dumps(rep_gen.generate_cash_flow_report(dao=thread_dao))
     kill_thread_db_session(thread_dao)
     return return_json
Example #20
0
 def POST(self, report_file_name):
     web.header('Content-Type', 'application/json')
     thread_dao = dao()
     return_json = json.dumps(rep_gen.get_hist_files_list())
     kill_thread_db_session(thread_dao)
     return return_json
Example #21
0
 def GET(self):
     web.header('Content-Type', 'application/json')
     thread_dao = dao(engine=engine)
     return_json = json.dumps(thread_dao.available_back_ups)
     kill_thread_db_session(thread_dao)
     return return_json
Example #22
0
# for useful_info_section in useful_info_sections:
#     session.add(useful_info_section)
#
# UsefulInfoElement(useful_info_sections[0], title=u'Tel.', data=u'9 11 9999 9999')
# UsefulInfoElement(useful_info_sections[0], title=u'Mail', data=u'*****@*****.**')
# UsefulInfoElement(useful_info_sections[0], title=u'Dirección', data=u'Calle 12345, CABA')
# UsefulInfoElement(useful_info_sections[0], title=u'Atención', data=u'Lunes a Viernes, 9 a 18 Hs')
#
# UsefulInfoElement(useful_info_sections[1], title=u'Título 1', data=u'Datos 1')
# UsefulInfoElement(useful_info_sections[1], title=u'Título 2', data=u'Datos 2')
#
# session.commit()

Dao = DaoPostgre
Session = scoped_session(sessionmaker())


def dao():
    return Dao(Session())


def kill_thread_db_session():
    Session.remove()

thread_dao = dao()
project = thread_dao.retrieve_project(1)
print project.budget.certificates
for certificate in filter(lambda c: c.id != 0, project.budget.certificates):
    print certificate.total_amount
    print project.budget.accumulated_certificate(certificate.date).total_amount
Example #23
0
Dao = DaoPostgre
Session = scoped_session(sessionmaker())


def dao(engine=None):
    return Dao(Session(), engine)


def kill_thread_db_session(dao=None):
    if dao is not None:
        dao.session.rollback()
    Session.remove()

rep_gen = ReportsGenerator()
imp_file = ImportOffers(dao())
kill_thread_db_session()


# Any request that is not a front end element should be listed before the * regular expression
urls = (
    '/', 'Index',
    '/ofertas', 'OffersResource',
    '/ofertas/sin_pagos', 'OffersNoPaymentsResource',
    '/ofertas/guardar_cambios', 'OffersSaveChangesResource',
    '/oferta/([0-9]+)', 'OfferResource',
    '/oferta/guardar', 'OfferSaveResource',
    '/oferta/eliminar/([0-9]+)', 'OfferDeleteResource',
    '/proveedores', 'SuppliersResource',
    '/proveedor/([0-9]+)', 'SupplierResource',
    '/proveedor/guardar', 'SupplierSaveResource',