return self.descripcion != "No ICE"
def __unicode__(self):
return u"{:.0f}% - {}".format(self.porcentaje, self.descripcion)
SRIStatus = Enum(
"SRIStatus",
( # Invalido o no enviado
('NotSent', 'No enviado al SRI'),
# Tiene fecha y punto de emision
# Al enviar se genera XML, clave de acceso
# y se incrementan secuenciales
('ReadyToSend', 'Enviando al SRI'),
# Enviada al SRI, esperando aceptacion o rechazo
('Sent', 'Enviada al SRI'),
# Aceptada por el SRI
('Accepted', 'Aceptada por el SRI'),
# Rechazada por el SRI, puede volver a ser modificada y enviada
('Rejected', 'Rechazada por el SRI'),
# Estaba aceptado por el SRI y fue anulado
('Annulled', 'Anulado'),
))
AmbienteSRI = Enum("AmbienteSRI",
(('pruebas', 'Pruebas'), ('produccion', 'Producción')))
class ComprobanteSRIMixin(models.Model):
# * encoding: utf-8 *
from decimal import Decimal
from django.db import models
from django.core.urlresolvers import reverse
import company_accounts.models
from sri.models import Tax, Iva, Ice
from util.enum import Enum
import purchases.models
ItemTipo = Enum("ItemTipo", (
('producto', 'Producto (ej. papas, muebles, televisores)'),
('servicio', 'Servicio (ej. reparación, transporte, instalación)'),
))
ItemDecimales = Enum("ItemDecimales", (
(0, 'El artículo se vende por unidades enteras'),
(2, 'El artículo se vende por décimas partes'),
(2, 'El artículo se vende por centésimas partes (centímetros)'),
(3, 'El artículo se vende por milésimas partes (gramos, milímetros)'),
))
class Item(models.Model):
"""
Represents an item that can be sold or bought
"""
name = models.CharField(max_length=100)
code = models.CharField(max_length=50)
class CanFrameParser(object):
'''
classdocs
'''
verbose = False
Fields = Enum([
'Mnemonic', 'Time', 'CanId', 'Byte0', 'Byte1', 'Byte2', 'Byte3',
'Byte4', 'Byte5', 'Byte6', 'Byte7'
])
frame_0C2_extractor = CanFrame0C2Extractor()
frame_14A_extractor = CanFrame14AExtractor()
frame_242_extractor = CanFrame242Extractor()
frame_245_extractor = CanFrame245Extractor()
frame_246_extractor = CanFrame246Extractor()
frame_24A_extractor = CanFrame24AExtractor()
frame_308_extractor = CanFrame308Extractor()
frame_441_extractor = CanFrame441Extractor()
frame_442_extractor = CanFrame442Extractor()
frame_44B_extractor = CanFrame44BExtractor()
@staticmethod
def can_time(field_data):
return float(field_data[CanFrameParser.Fields.Time])
@staticmethod
def can_id(field_data):
return int(field_data[CanFrameParser.Fields.CanId], 16)
@staticmethod
def extractor_factory(can_id):
if can_id == 0x0C2:
return CanFrameParser.frame_0C2_extractor
elif can_id == 0x14A:
return CanFrameParser.frame_14A_extractor
elif can_id == 0x242:
return CanFrameParser.frame_242_extractor
elif can_id == 0x245:
return CanFrameParser.frame_245_extractor
elif can_id == 0x246:
return CanFrameParser.frame_246_extractor
elif can_id == 0x24A:
return CanFrameParser.frame_24A_extractor
elif can_id == 0x308:
return CanFrameParser.frame_308_extractor
elif can_id == 0x441:
return CanFrameParser.frame_441_extractor
elif can_id == 0x442:
return CanFrameParser.frame_442_extractor
elif can_id == 0x44B:
return CanFrameParser.frame_44B_extractor
else:
raise ValueError(
"No known extractor for CAN ID 0x{0:X}".format(can_id))
@staticmethod
def frame_byte(field_data, byte_idx):
if byte_idx == 0:
return int(field_data[CanFrameParser.Fields.Byte0], 16)
elif byte_idx == 1:
return int(field_data[CanFrameParser.Fields.Byte1], 16)
elif byte_idx == 2:
return int(field_data[CanFrameParser.Fields.Byte2], 16)
elif byte_idx == 3:
return int(field_data[CanFrameParser.Fields.Byte3], 16)
elif byte_idx == 4:
return int(field_data[CanFrameParser.Fields.Byte4], 16)
elif byte_idx == 5:
return int(field_data[CanFrameParser.Fields.Byte5], 16)
elif byte_idx == 6:
return int(field_data[CanFrameParser.Fields.Byte6], 16)
elif byte_idx == 7:
return int(field_data[CanFrameParser.Fields.Byte7], 16)
else:
raise ValueError(
"The byte index of a CAN frame must be between 0 and 7")
@staticmethod
def frame_word(field_data, word_idx):
if word_idx == 0:
return int(
field_data[CanFrameParser.Fields.Byte1] +
field_data[CanFrameParser.Fields.Byte0], 16)
elif word_idx == 2:
return int(
field_data[CanFrameParser.Fields.Byte3] +
field_data[CanFrameParser.Fields.Byte2], 16)
elif word_idx == 4:
return int(
field_data[CanFrameParser.Fields.Byte5] +
field_data[CanFrameParser.Fields.Byte4], 16)
elif word_idx == 6:
return int(
field_data[CanFrameParser.Fields.Byte7] +
field_data[CanFrameParser.Fields.Byte7], 16)
else:
raise ValueError(
"The word index of a CAN frame must be 0, 2, 4, or 6")
@staticmethod
def frame_int16(field_data, word_idx):
value = CanFrameParser.frame_word(field_data, word_idx)
if (value > 32767):
value -= 65535
return value
def __init__(self, state):
'''
Constructor
'''
self.state = state
def parse(self, sentence):
field_data = sentence.split(',')
try:
extractor = CanFrameParser.extractor_factory(
CanFrameParser.can_id(field_data))
extractor.extractData(field_data, self.state)
self.state.set_data_item(DataState.names[DataState.names.Time],
CanFrameParser.can_time(field_data))
except (ValueError, IndexError) as err:
print("Failed to parse CAN message: {0}".format(err))