class OrderSerializer(serializers.Serializer):
order_id = serializers.IntegerField(validators=[UniqueValidator(queryset=Order.objects.all())])
weight = serializers.FloatField()
region = serializers.IntegerField()
delivery_hours = serializers.ListField(allow_empty=False, child=serializers.CharField(max_length=12))
courier = serializers.PrimaryKeyRelatedField(required=False, allow_null=True, many=True,
queryset=Courier.objects.all())
assign_to_courier_time = serializers.DateTimeField(required=False)
completed_time = serializers.DateTimeField(required=False)
delivery_type = serializers.CharField(max_length=4, required=False)
def validate_order_id(self, value):
if type(value) is not int:
raise ValidationError('Id must be integer')
if value <= 0:
raise ValidationError('Id must be positive integer')
return value
def validate_weight(self, value):
if value is None:
raise ValidationError('Value is absent')
if type(value) in (float, int):
if value < 0.01 or value > 50:
raise ValidationError('Value is out of bounds [0.01;50] : {}'.format(value))
return value
else:
raise ValidationError('Type of regions is not float : {}'.format(type(value)))
def validate_region(self, value):
if value is None:
raise ValidationError('Region must be specified')
if type(value) is not int:
raise ValidationError('Region must be exactly one integer')
if value <= 0:
raise ValidationError('Region must be positive integer')
return value
def validate_delivery_hours(self, value):
if value is None:
raise ValidationError('Value is absent')
if type(value) is not list:
raise ValidationError('Delivery hours must be enumerated in list data structure')
if len(value) == 0:
raise ValidationError('There must be at least one delivery period')
for delivery_period in value:
if type(delivery_period) is not str:
raise ValidationError('Working period regions type is not string')
try:
for hour_stamp in get_start_end_period(delivery_period):
if not is_correct_hours(hour_stamp):
raise ValidationError()
except Exception:
raise ValidationError('Incorrect delivery period: {}'.format(delivery_period))
return value
def validate_assign_to_courier_time(self, value):
if value is None:
raise ValidationError('Value is absent')
if type(value) is not list:
raise ValidationError('Time of order assignment must be exactly one timestamp')
try:
res = dt.strptime(value, '%Y-%m-%dT%H:%M:%S.%fZ').strftime('%Y-%m-%dT%H:%M:%S.%fZ')
if res != value:
raise Exception()
return value
except Exception:
raise ValidationError('incorrect delivery_timestamp')
def validate_courier(self, value: Courier):
try:
c = Courier.objects.filter(pk=value.courier_id).all()
return value
except Courier.DoesNotExist:
raise ValidationError('There is no such a courier with id {c_id}'.format(c_id=value.courier_id))
def validate_completed_time(self, value):
if value is None:
raise ValidationError('Value is absent')
try:
self.validate_delivery_hours(value)
return value
except ValidationError:
raise ValidationError('incorrect timestamp of order completion')
def validate_delivery_type(self, value):
if value is None:
raise ValidationError('Delivery type must be specified')
if type(value) is not str:
raise ValidationError('Delivery type must be exactly one string')
if value not in Courier.COURIER_MAX_WEIGHT.keys():
message = 'Courier type must be one of these types: [{types}]. Input regions : {input_c_type}' \
.format(types=', '.join(Courier.COURIER_MAX_WEIGHT.keys()), input_c_type=value)
raise ValidationError(message)
return value
def update(self, instance: Order, validated_data: dict):
for key in validated_data.keys():
instance[key] = validated_data[key]
instance.save()
return instance
def create(self, validated_data):
return Order.objects.create(**validated_data)
class MOMRevenueSerializer(serializers.Serializer):
revenue = serializers.FloatField()
month = serializers.CharField()
year = serializers.CharField()
DataType = serializers.CharField()
class ChannelWisePerformSerializer(serializers.Serializer):
channel = serializers.CharField()
cy_revenue = serializers.FloatField()
ly_revenue = serializers.FloatField()
vly_revenue = serializers.FloatField()
class WaveModelSerializer(serializers.Serializer):
date = serializers.DateTimeField()
value = serializers.FloatField()
class IndicatorsSerializer(serializers.Serializer):
id_form = serializers.CharField()
name = serializers.CharField()
total = serializers.FloatField()
percentage = serializers.FloatField()
class SumTransactionByDateSerializer(serializers.Serializer):
date = serializers.DateField()
sum = serializers.FloatField()
class SaleRefundSerializer(serializers.ModelSerializer):
refund_fee_message = serializers.SerializerMethodField()
tid = serializers.CharField(source='sale_trade.tid')
channel_display = serializers.CharField(
source='sale_trade.get_channel_display')
status_display = serializers.CharField(source='get_status_display',
read_only=True)
good_status_display = serializers.CharField(
source='get_good_status_display', read_only=True)
trade_logistics_company = serializers.CharField(
source='package_skuitem.logistics_company_name')
trade_out_sid = serializers.CharField(source='package_skuitem.out_sid')
trade_consign_time = serializers.DateTimeField(
source='package_skuitem.finish_time')
order_pic_path = serializers.CharField(source='saleorder.pic_path')
order_payment = serializers.FloatField(source='saleorder.payment')
order_status = serializers.IntegerField(source='saleorder.status')
order_pay_time = serializers.DateTimeField(source='saleorder.pay_time')
order_status_display = serializers.CharField(
source='saleorder.get_status_display')
postage_num_money = serializers.FloatField(
source='get_postage_num_display')
coupon_num_money = serializers.FloatField(source='get_coupon_num_display')
manual_refund = serializers.SerializerMethodField()
class Meta:
model = SaleRefund
fields = ('id', 'refund_no', 'trade_id', 'order_id', 'buyer_id',
'buyer_nick', 'mobile', 'phone', 'refund_id', 'charge',
'channel', 'refund_channel', 'item_id', 'title', 'sku_id',
'sku_name', 'ware_by', 'refund_num', 'total_fee', 'payment',
'refund_fee', 'amount_flow', 'success_time', 'company_name',
'sid', 'reason', 'proof_pic', 'desc', 'feedback',
'has_good_return', 'has_good_change', 'is_lackrefund',
'lackorder_id', 'good_status', 'status', 'postage_num',
'coupon_num', 'refund_fee_message', 'tid', 'channel_display',
'status_display', 'good_status_display',
'trade_logistics_company', 'trade_out_sid',
'trade_consign_time', 'order_pic_path', 'order_payment',
'order_status', 'order_pay_time', 'order_status_display',
'postage_num_money', 'coupon_num_money', 'manual_refund')
def get_refund_fee_message(self, obj):
trade = obj.sale_trade
if obj.is_fastrefund: # 如果是极速退款
return "[1]退回小鹿钱包 %.2f 元 实付余额%.2f" % (
obj.refund_fee, trade.payment > 0 and
(obj.refund_fee / trade.payment) *
(obj.payment - trade.pay_cash) or 0)
budget_logs = obj.get_refund_budget_logs()
if budget_logs:
log_money = sum(
[budget_log.flow_amount for budget_log in budget_logs]) / 100.0
return '退回小鹿钱包%.2f元 实付金额%.2f' % (log_money, obj.payment)
return "[2]退回%s %.2f元" % (trade.get_channel_display(), obj.refund_fee)
def get_manual_refund(self, obj):
"""是否是手动退款
1. 退款单 买家已经退货 退货待审状态 仓库已经收到货(没有 退款给用户)
"""
if obj.good_status == SaleRefund.BUYER_RETURNED_GOODS and \
obj.status == SaleRefund.REFUND_CONFIRM_GOODS and \
obj.refundproduct:
return True
return False
class SalesOrderAllocationSerializer(InvenTreeModelSerializer):
"""
Serializer for the SalesOrderAllocation model.
This includes some fields from the related model objects.
"""
part = serializers.PrimaryKeyRelatedField(source='item.part',
read_only=True)
order = serializers.PrimaryKeyRelatedField(source='line.order',
many=False,
read_only=True)
serial = serializers.CharField(source='get_serial', read_only=True)
quantity = serializers.FloatField(read_only=False)
location = serializers.PrimaryKeyRelatedField(source='item.location',
many=False,
read_only=True)
# Extra detail fields
order_detail = SalesOrderSerializer(source='line.order',
many=False,
read_only=True)
part_detail = PartBriefSerializer(source='item.part',
many=False,
read_only=True)
item_detail = StockItemSerializer(source='item',
many=False,
read_only=True)
location_detail = LocationSerializer(source='item.location',
many=False,
read_only=True)
def __init__(self, *args, **kwargs):
order_detail = kwargs.pop('order_detail', False)
part_detail = kwargs.pop('part_detail', False)
item_detail = kwargs.pop('item_detail', False)
location_detail = kwargs.pop('location_detail', False)
super().__init__(*args, **kwargs)
if not order_detail:
self.fields.pop('order_detail')
if not part_detail:
self.fields.pop('part_detail')
if not item_detail:
self.fields.pop('item_detail')
if not location_detail:
self.fields.pop('location_detail')
class Meta:
model = SalesOrderAllocation
fields = [
'pk',
'line',
'serial',
'quantity',
'location',
'location_detail',
'item',
'item_detail',
'order',
'order_detail',
'part',
'part_detail',
]
class SOLineItemSerializer(InvenTreeModelSerializer):
""" Serializer for a SalesOrderLineItem object """
def __init__(self, *args, **kwargs):
part_detail = kwargs.pop('part_detail', False)
order_detail = kwargs.pop('order_detail', False)
allocations = kwargs.pop('allocations', False)
super().__init__(*args, **kwargs)
if part_detail is not True:
self.fields.pop('part_detail')
if order_detail is not True:
self.fields.pop('order_detail')
if allocations is not True:
self.fields.pop('allocations')
order_detail = SalesOrderSerializer(source='order',
many=False,
read_only=True)
part_detail = PartBriefSerializer(source='part',
many=False,
read_only=True)
allocations = SalesOrderAllocationSerializer(many=True,
read_only=True,
location_detail=True)
quantity = serializers.FloatField()
allocated = serializers.FloatField(source='allocated_quantity',
read_only=True)
fulfilled = serializers.FloatField(source='fulfilled_quantity',
read_only=True)
sale_price = InvenTreeMoneySerializer(max_digits=19,
decimal_places=4,
allow_null=True)
sale_price_string = serializers.CharField(source='sale_price',
read_only=True)
sale_price_currency = serializers.ChoiceField(
choices=currency_code_mappings(),
help_text=_('Sale price currency'),
)
class Meta:
model = SalesOrderLineItem
fields = [
'pk',
'allocated',
'allocations',
'quantity',
'fulfilled',
'reference',
'notes',
'order',
'order_detail',
'part',
'part_detail',
'sale_price',
'sale_price_currency',
'sale_price_string',
]
class OrderSerializer(serializers.ModelSerializer):
"""
订单的序列化
"""
order_user = serializers.HiddenField(
default=serializers.CurrentUserDefault())
order_table = serializers.PrimaryKeyRelatedField(
queryset=Table.objects.all())
order_detail = OrderDetailSerializer(many=True)
order_price = serializers.FloatField(required=True, write_only=True)
pay_method = serializers.IntegerField(write_only=True)
order_status = serializers.IntegerField(required=True, write_only=True)
# 交易信息时自动创建的，故只能读取
transaction = TransactionSerializer(read_only=True)
class Meta:
model = Order
fields = ('order_id', 'order_user', 'order_table', 'order_price',
'order_script', 'order_status', 'order_detail',
'table_ware_num', 'pay_method', 'transaction')
extra_kwargs = {"order_script": {"allow_null": True}}
def validate_pay_method(self, data):
if data == 0 or data == 1:
return data
else:
raise serializers.ValidationError("支付方式异常")
def validate(self, attrs):
order_details = attrs["order_detail"]
price = 0
# 验证价格计算正确
for detail in order_details:
dish = Dish.objects.filter(dish_id=detail['dish_id'])
if not dish:
raise serializers.ValidationError("菜品信息错误")
else:
price += dish[0].dish_price * int(detail['dish_num'])
if price != attrs['order_price']:
raise serializers.ValidationError("价格异常")
return attrs
def create(self, validated_data):
order_details = validated_data.pop("order_detail")
order_price = validated_data.pop('order_price')
order_status = validated_data.pop('order_status')
pay_method = validated_data.pop('pay_method')
order = Order.objects.create(**validated_data)
# validated_data['order_user'] = User.objects.get(username="******")
for detail in order_details:
dish = Dish.objects.get(dish_id=detail['dish_id'])
OrderDetail.objects.create(
**detail,
order=order,
dish_name=dish.dish_name,
dish_price=dish.dish_price,
dish_picture=dish.dish_picture,
dish_description=dish.dish_description,
)
Transaction.objects.create(
order=order,
order_price=order_price,
order_status=order_status,
pay_method=pay_method,
)
return order
class POLineItemSerializer(InvenTreeModelSerializer):
@staticmethod
def annotate_queryset(queryset):
"""
Add some extra annotations to this queryset:
- Total price = purchase_price * quantity
"""
queryset = queryset.annotate(
total_price=ExpressionWrapper(F('purchase_price') * F('quantity'),
output_field=models.DecimalField()))
return queryset
def __init__(self, *args, **kwargs):
part_detail = kwargs.pop('part_detail', False)
super().__init__(*args, **kwargs)
if part_detail is not True:
self.fields.pop('part_detail')
self.fields.pop('supplier_part_detail')
quantity = serializers.FloatField(default=1)
received = serializers.FloatField(default=0)
total_price = serializers.FloatField(read_only=True)
part_detail = PartBriefSerializer(source='get_base_part',
many=False,
read_only=True)
supplier_part_detail = SupplierPartSerializer(source='part',
many=False,
read_only=True)
purchase_price = InvenTreeMoneySerializer(max_digits=19,
decimal_places=4,
allow_null=True)
purchase_price_string = serializers.CharField(source='purchase_price',
read_only=True)
destination_detail = LocationBriefSerializer(source='get_destination',
read_only=True)
purchase_price_currency = serializers.ChoiceField(
choices=currency_code_mappings(),
help_text=_('Purchase price currency'),
)
class Meta:
model = PurchaseOrderLineItem
fields = [
'pk',
'quantity',
'reference',
'notes',
'order',
'part',
'part_detail',
'supplier_part_detail',
'received',
'purchase_price',
'purchase_price_currency',
'purchase_price_string',
'destination',
'destination_detail',
'total_price',
]
class PredictedPricesSerializer(serializers.ModelSerializer):
predicted_price = serializers.FloatField(source="y_pred")
class Meta:
model = PredictedPrices
fields = ("county_id", "predicted_price", "home_type_id")
class BomItemSerializer(InvenTreeModelSerializer):
""" Serializer for BomItem object """
price_range = serializers.CharField(read_only=True)
quantity = serializers.FloatField()
part = serializers.PrimaryKeyRelatedField(queryset=Part.objects.filter(
assembly=True))
part_detail = PartBriefSerializer(source='part',
many=False,
read_only=True)
sub_part = serializers.PrimaryKeyRelatedField(queryset=Part.objects.filter(
component=True))
sub_part_detail = PartBriefSerializer(source='sub_part',
many=False,
read_only=True)
validated = serializers.BooleanField(read_only=True,
source='is_line_valid')
def __init__(self, *args, **kwargs):
# part_detail and sub_part_detail serializers are only included if requested.
# This saves a bunch of database requests
part_detail = kwargs.pop('part_detail', False)
sub_part_detail = kwargs.pop('sub_part_detail', False)
super(BomItemSerializer, self).__init__(*args, **kwargs)
if part_detail is not True:
self.fields.pop('part_detail')
if sub_part_detail is not True:
self.fields.pop('sub_part_detail')
@staticmethod
def setup_eager_loading(queryset):
queryset = queryset.prefetch_related('part')
queryset = queryset.prefetch_related('part__category')
queryset = queryset.prefetch_related('part__stock_items')
queryset = queryset.prefetch_related('sub_part')
queryset = queryset.prefetch_related('sub_part__category')
queryset = queryset.prefetch_related('sub_part__stock_items')
queryset = queryset.prefetch_related(
'sub_part__supplier_parts__pricebreaks')
return queryset
class Meta:
model = BomItem
fields = [
'pk',
'part',
'part_detail',
'sub_part',
'sub_part_detail',
'quantity',
'reference',
'price_range',
'overage',
'note',
'validated',
]
class SetPriceAlarmSerializer(serializers.Serializer):
product_id = serializers.IntegerField(required=True)
price = serializers.FloatField(required=True)
class TranslationSerializer(RemovableSerializer):
web_url = AbsoluteURLField(source="get_absolute_url", read_only=True)
share_url = AbsoluteURLField(source="get_share_url", read_only=True)
translate_url = AbsoluteURLField(source="get_translate_url",
read_only=True)
component = ComponentSerializer(read_only=True)
language = LanguageSerializer(read_only=True)
is_template = serializers.BooleanField(read_only=True)
is_source = serializers.BooleanField(read_only=True)
total = serializers.IntegerField(source="stats.all", read_only=True)
total_words = serializers.IntegerField(source="stats.all_words",
read_only=True)
translated = serializers.IntegerField(source="stats.translated",
read_only=True)
translated_words = serializers.IntegerField(
source="stats.translated_words", read_only=True)
translated_percent = serializers.FloatField(
source="stats.translated_percent", read_only=True)
fuzzy = serializers.IntegerField(source="stats.fuzzy", read_only=True)
fuzzy_words = serializers.IntegerField(source="stats.fuzzy_words",
read_only=True)
fuzzy_percent = serializers.FloatField(source="stats.fuzzy_percent",
read_only=True)
failing_checks = serializers.IntegerField(source="stats.allchecks",
read_only=True)
failing_checks_words = serializers.IntegerField(
source="stats.allchecks_words", read_only=True)
failing_checks_percent = serializers.FloatField(
source="stats.allchecks_percent", read_only=True)
have_suggestion = serializers.IntegerField(source="stats.suggestions",
read_only=True)
have_comment = serializers.IntegerField(source="stats.comments",
read_only=True)
last_change = serializers.DateTimeField(source="stats.last_changed",
read_only=True)
last_author = serializers.CharField(source="get_last_author",
read_only=True)
repository_url = MultiFieldHyperlinkedIdentityField(
view_name="api:translation-repository",
lookup_field=("component__project__slug", "component__slug",
"language__code"),
)
statistics_url = MultiFieldHyperlinkedIdentityField(
view_name="api:translation-statistics",
lookup_field=("component__project__slug", "component__slug",
"language__code"),
)
file_url = MultiFieldHyperlinkedIdentityField(
view_name="api:translation-file",
lookup_field=("component__project__slug", "component__slug",
"language__code"),
)
changes_list_url = MultiFieldHyperlinkedIdentityField(
view_name="api:translation-changes",
lookup_field=("component__project__slug", "component__slug",
"language__code"),
)
units_list_url = MultiFieldHyperlinkedIdentityField(
view_name="api:translation-units",
lookup_field=("component__project__slug", "component__slug",
"language__code"),
)
serializer_url_field = MultiFieldHyperlinkedIdentityField
class Meta:
model = Translation
fields = (
"language",
"component",
"language_code",
"id",
"filename",
"revision",
"web_url",
"share_url",
"translate_url",
"url",
"is_template",
"is_source",
"total",
"total_words",
"translated",
"translated_words",
"translated_percent",
"fuzzy",
"fuzzy_words",
"fuzzy_percent",
"failing_checks",
"failing_checks_words",
"failing_checks_percent",
"have_suggestion",
"have_comment",
"last_change",
"last_author",
"repository_url",
"file_url",
"statistics_url",
"changes_list_url",
"units_list_url",
)
extra_kwargs = {
"url": {
"view_name":
"api:translation-detail",
"lookup_field": (
"component__project__slug",
"component__slug",
"language__code",
),
}
}
class YearSerializer(serializers.Serializer):
Low = serializers.FloatField()
High = serializers.FloatField()
class MyNumberSerializer(serializers.BaseSerializer):
number = serializers.FloatField()
class BusinessUserCenterSerializer(serializers.Serializer):
pn = serializers.CharField()
total_amount = serializers.FloatField()
recycle_bin = RecycleBinBasicInfoSerializer()
class TeamResultSerializer(serializers.Serializer):
side = serializers.CharField()
points = serializers.IntegerField(required=False)
win = serializers.BooleanField(required=False)
score = serializers.FloatField(required=False)
team = fields.TournamentHyperlinkedRelatedField(
view_name='api-team-detail',
queryset=Team.objects.all(),
)
class SpeechSerializer(serializers.Serializer):
ghost = serializers.BooleanField(required=False)
score = serializers.FloatField()
speaker = fields.TournamentHyperlinkedRelatedField(
view_name='api-speaker-detail',
queryset=Speaker.objects.all(),
tournament_field='team__tournament',
)
def save(self, **kwargs):
"""Requires `result`, `side`, `seq`, and `adjudicator` as extra"""
result = kwargs['result']
speaker_args = [kwargs['side'], kwargs['seq']]
result.set_speaker(*speaker_args,
self.validated_data['speaker'])
if self.validated_data.get('ghost', False):
result.set_ghost(*speaker_args)
if kwargs.get('adjudicator') is not None:
speaker_args.insert(0, kwargs['adjudicator'])
result.set_score(*speaker_args,
self.validated_data['score'])
return result
speeches = SpeechSerializer(many=True, required=False)
def validate(self, data):
# Make sure the score is the sum of the speech scores
score = data.get('score', None)
speeches = data.get('speeches', None)
if speeches is None:
if score is not None:
raise serializers.ValidationError(
"Speeches are required to assign scores.")
elif score is not None and score != sum(
speech['score'] for speech in speeches):
raise serializers.ValidationError(
"Score must be the sum of speech scores.")
# Speakers must be in correct team
team = data.get('team', None)
speakers_team = set(s['speaker'].team_id for s in speeches)
if team is None or len(speakers_team) > 1 or (
len(speakers_team) == 1
and team.id not in speakers_team):
raise serializers.ValidationError(
"Speakers must be in their team.")
return data
def save(self, **kwargs):
result = kwargs['result']
if result.get_scoresheet_class(
).uses_declared_winners and self.validated_data.get(
'win', False):
args = [self.validated_data['side']]
if self.validated_data.get('adjudicator') is not None:
args.insert(0, self.validated_data['adjudicator'])
result.add_winner(*args)
speech_serializer = self.SpeechSerializer(
context=self.context)
for i, speech in enumerate(
self.validated_data.get('speeches', []), 1):
speech_serializer._validated_data = speech
speech_serializer.save(
result=result,
side=self.validated_data['side'],
seq=i,
adjudicator=kwargs.get('adjudicator'),
)
return result
class UploadGpsSerializer(serializers.Serializer):
user_sid = serializers.CharField(max_length=128)
lat = serializers.FloatField()
lng = serializers.FloatField()
class AuceSerializer(serializers.Serializer):
name = serializers.CharField()
fit_type = serializers.CharField()
subject_ids = serializers.ListField(child=serializers.IntegerField())
concentrations = serializers.ListField(child=serializers.FloatField())
auce = serializers.ListField(child=serializers.FloatField())
x = serializers.ListField(child=serializers.FloatField())
y = serializers.ListField(child=serializers.FloatField())
y_upper = serializers.ListField(child=serializers.FloatField())
y_lower = serializers.ListField(child=serializers.FloatField())
fit_EC50 = serializers.FloatField()
sigma_EC50 = serializers.FloatField()
fit_top = serializers.FloatField()
sigma_top = serializers.FloatField()
fit_bottom = serializers.FloatField()
sigma_bottom = serializers.FloatField()
class SharePoolSerializer(serializers.ModelSerializer):
size_gb = serializers.FloatField()
class Meta:
model = Share
class ActivitySerializer(serializers.Serializer):
BVP = serializers.FloatField()
wrist_ACC_X = serializers.FloatField()
wrist_ACC_Y = serializers.FloatField()
wrist_ACC_Z = serializers.FloatField()
EDA = serializers.FloatField()
chest_ACC_X = serializers.FloatField()
chest_ACC_Y = serializers.FloatField()
chest_ACC_Z = serializers.FloatField()
chest_ECG = serializers.FloatField()
chest_EMG = serializers.FloatField()
chest_EDA = serializers.FloatField()
chest_Temp = serializers.FloatField()
chest_Resp = serializers.FloatField()
rpeaks = serializers.FloatField()
WEIGHT = serializers.FloatField()
AGE = serializers.FloatField()
HEIGHT = serializers.FloatField()
SKIN = serializers.FloatField()
SPORT = serializers.FloatField()
f = serializers.FloatField()
m = serializers.FloatField()
Activities = serializers.FloatField(allow_null=True)
def create(self, validated_data):
return (Activity.objects.create(**validated_data))
def update(self, instance, validated_date):
instance.BVP = validated_data.get('BVP', instance.BVP)
instance.wrist_ACC_X = validated_data.get('wrist_ACC_X',
instance.wrist_ACC_X)
instance.wrist_ACC_Y = validated_data.get('wrist_ACC_Y',
instance.wrist_ACC_Y)
instance.wrist_ACC_Z = validated_data.get('wrist_ACC_Z',
instance.wrist_ACC_Z)
instance.EDA = validated_data.get('EDA', instance.EDA)
instance.chest_ACC_X = validated_data.get('chest_ACC_X',
instance.chest_ACC_X)
instance.chest_ACC_Y = validated_data.get('chest_ACC_Y',
instance.chest_ACC_Y)
instance.chest_ACC_Z = validated_data.get('chest_ACC_Z',
instance.chest_ACC_Z)
instance.chest_ECG = validated_data.get('chest_ECG',
instance.chest_ECG)
instance.chest_EMG = validated_data.get('chest_EMG',
instance.chest_EMG)
instance.chest_EDA = validated_data.get('chest_EDA',
instance.chest_EDA)
instance.chest_Temp = validated_data.get('chest_Temp',
instance.chest_Temp)
instance.chest_Resp = validated_data.get('chest_Resp',
instance.chest_Resp)
instance.rpeaks = validated_rpeaks.get('rpeaks', instance.rpeaks)
instance.WEIGHT = validated_data.get('WEIGHT', instance.WEIGHT)
instance.AGE = validated_data.get('AGE', instance.AGE)
instance.HEIGHT = validated_data.get('HEIGHT', instance.HEIGHT)
instance.SKIN = validated_data.get('SKIN', instance.SKIN)
instance.SPORT = validated_data.get('SPORT', instance.SPORT)
instance.f = validated_data.get('f', instance.f)
instance.m = validated_data.get('m', instance.m)
instance.Activities = validated_data.gey('Activities',
instance.Activities)
instance.save()
return (instance)
class PartSerializer(InvenTreeModelSerializer):
""" Serializer for complete detail information of a part.
Used when displaying all details of a single component.
"""
def get_api_url(self):
return reverse_lazy('api-part-list')
def __init__(self, *args, **kwargs):
"""
Custom initialization method for PartSerializer,
so that we can optionally pass extra fields based on the query.
"""
self.starred_parts = kwargs.pop('starred_parts', [])
category_detail = kwargs.pop('category_detail', False)
super().__init__(*args, **kwargs)
if category_detail is not True:
self.fields.pop('category_detail')
@staticmethod
def annotate_queryset(queryset):
"""
Add some extra annotations to the queryset,
performing database queries as efficiently as possible,
to reduce database trips.
"""
# Annotate with the total 'in stock' quantity
queryset = queryset.annotate(in_stock=Coalesce(
SubquerySum('stock_items__quantity',
filter=StockItem.IN_STOCK_FILTER),
Decimal(0),
output_field=models.DecimalField(),
), )
# Annotate with the total number of stock items
queryset = queryset.annotate(
stock_item_count=SubqueryCount('stock_items'))
# Filter to limit builds to "active"
build_filter = Q(status__in=BuildStatus.ACTIVE_CODES)
# Annotate with the total 'building' quantity
queryset = queryset.annotate(building=Coalesce(
SubquerySum('builds__quantity', filter=build_filter),
Decimal(0),
output_field=models.DecimalField(),
))
# Filter to limit orders to "open"
order_filter = Q(order__status__in=PurchaseOrderStatus.OPEN)
# Annotate with the total 'on order' quantity
queryset = queryset.annotate(ordering=Coalesce(
SubquerySum('supplier_parts__purchase_order_line_items__quantity',
filter=order_filter),
Decimal(0),
output_field=models.DecimalField(),
) - Coalesce(
SubquerySum('supplier_parts__purchase_order_line_items__received',
filter=order_filter),
Decimal(0),
output_field=models.DecimalField(),
))
# Annotate with the number of 'suppliers'
queryset = queryset.annotate(suppliers=Coalesce(
SubqueryCount('supplier_parts'),
Decimal(0),
output_field=models.DecimalField(),
), )
return queryset
def get_starred(self, part):
"""
Return "true" if the part is starred by the current user.
"""
return part in self.starred_parts
# Extra detail for the category
category_detail = CategorySerializer(source='category',
many=False,
read_only=True)
# Calculated fields
in_stock = serializers.FloatField(read_only=True)
ordering = serializers.FloatField(read_only=True)
building = serializers.FloatField(read_only=True)
stock_item_count = serializers.IntegerField(read_only=True)
suppliers = serializers.IntegerField(read_only=True)
image = InvenTreeImageSerializerField(required=False, allow_null=True)
thumbnail = serializers.CharField(source='get_thumbnail_url',
read_only=True)
starred = serializers.SerializerMethodField()
# PrimaryKeyRelated fields (Note: enforcing field type here results in much faster queries, somehow...)
category = serializers.PrimaryKeyRelatedField(
queryset=PartCategory.objects.all())
# TODO - Include annotation for the following fields:
# allocated_stock = serializers.FloatField(source='allocation_count', read_only=True)
# bom_items = serializers.IntegerField(source='bom_count', read_only=True)
# used_in = serializers.IntegerField(source='used_in_count', read_only=True)
class Meta:
model = Part
partial = True
fields = [
'active',
# 'allocated_stock',
'assembly',
# 'bom_items',
'category',
'category_detail',
'component',
'default_expiry',
'default_location',
'default_supplier',
'description',
'full_name',
'image',
'in_stock',
'ordering',
'building',
'IPN',
'is_template',
'keywords',
'link',
'minimum_stock',
'name',
'notes',
'pk',
'purchaseable',
'revision',
'salable',
'starred',
'stock_item_count',
'suppliers',
'thumbnail',
'trackable',
'units',
# 'used_in',
'variant_of',
'virtual',
]
class top5ODsBarchartSerializer(serializers.Serializer):
CommonRoute = serializers.CharField()
CYRevenue = serializers.FloatField()
class BomItemSerializer(InvenTreeModelSerializer):
"""
Serializer for BomItem object
"""
price_range = serializers.CharField(read_only=True)
quantity = serializers.FloatField()
part = serializers.PrimaryKeyRelatedField(queryset=Part.objects.filter(
assembly=True))
substitutes = BomItemSubstituteSerializer(many=True, read_only=True)
part_detail = PartBriefSerializer(source='part',
many=False,
read_only=True)
sub_part = serializers.PrimaryKeyRelatedField(queryset=Part.objects.filter(
component=True))
sub_part_detail = PartBriefSerializer(source='sub_part',
many=False,
read_only=True)
validated = serializers.BooleanField(read_only=True,
source='is_line_valid')
purchase_price_min = MoneyField(max_digits=10,
decimal_places=6,
read_only=True)
purchase_price_max = MoneyField(max_digits=10,
decimal_places=6,
read_only=True)
purchase_price_avg = serializers.SerializerMethodField()
purchase_price_range = serializers.SerializerMethodField()
def __init__(self, *args, **kwargs):
# part_detail and sub_part_detail serializers are only included if requested.
# This saves a bunch of database requests
part_detail = kwargs.pop('part_detail', False)
sub_part_detail = kwargs.pop('sub_part_detail', False)
include_pricing = kwargs.pop('include_pricing', False)
super(BomItemSerializer, self).__init__(*args, **kwargs)
if part_detail is not True:
self.fields.pop('part_detail')
if sub_part_detail is not True:
self.fields.pop('sub_part_detail')
if not include_pricing:
# Remove all pricing related fields
self.fields.pop('price_range')
self.fields.pop('purchase_price_min')
self.fields.pop('purchase_price_max')
self.fields.pop('purchase_price_avg')
self.fields.pop('purchase_price_range')
@staticmethod
def setup_eager_loading(queryset):
queryset = queryset.prefetch_related('part')
queryset = queryset.prefetch_related('part__category')
queryset = queryset.prefetch_related('part__stock_items')
queryset = queryset.prefetch_related('sub_part')
queryset = queryset.prefetch_related('sub_part__category')
queryset = queryset.prefetch_related('sub_part__stock_items')
queryset = queryset.prefetch_related(
'sub_part__supplier_parts__pricebreaks')
return queryset
def get_purchase_price_range(self, obj):
""" Return purchase price range """
try:
purchase_price_min = obj.purchase_price_min
except AttributeError:
return None
try:
purchase_price_max = obj.purchase_price_max
except AttributeError:
return None
if purchase_price_min and not purchase_price_max:
# Get price range
purchase_price_range = str(purchase_price_max)
elif not purchase_price_min and purchase_price_max:
# Get price range
purchase_price_range = str(purchase_price_max)
elif purchase_price_min and purchase_price_max:
# Get price range
if purchase_price_min >= purchase_price_max:
# If min > max: use min only
purchase_price_range = str(purchase_price_min)
else:
purchase_price_range = str(purchase_price_min) + " - " + str(
purchase_price_max)
else:
purchase_price_range = '-'
return purchase_price_range
def get_purchase_price_avg(self, obj):
""" Return purchase price average """
try:
purchase_price_avg = obj.purchase_price_avg
except AttributeError:
return None
if purchase_price_avg:
# Get string representation of price average
purchase_price_avg = str(purchase_price_avg)
else:
purchase_price_avg = '-'
return purchase_price_avg
class Meta:
model = BomItem
fields = [
'allow_variants',
'inherited',
'note',
'optional',
'overage',
'pk',
'part',
'part_detail',
'purchase_price_avg',
'purchase_price_max',
'purchase_price_min',
'purchase_price_range',
'quantity',
'reference',
'sub_part',
'sub_part_detail',
'substitutes',
'price_range',
'validated',
]
class MOMAvgFareAnalysisSerializer(serializers.Serializer):
AvgFare = serializers.FloatField()
month = serializers.CharField()
year = serializers.CharField()
DataType = serializers.CharField()
class AssociateProfileSerializer(serializers.ModelSerializer):
organization_name = serializers.CharField(
required=False,
allow_blank=True,
allow_null=True,
max_length=63,
validators=[
UniqueValidator(
queryset=Associate.objects.all(),
)
],
)
organization_type_of = serializers.IntegerField(
required=False,
validators=[]
)
organization_type_of_label = serializers.ReadOnlyField(source="get_organization_type_of_label")
type_of = serializers.IntegerField(
required=False,
allow_null=True,
validators=[]
)
given_name = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
last_name = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
gender = serializers.CharField(
required=True,
allow_blank=False,
allow_null=False,
)
address_country = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
address_region = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
address_locality = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
postal_code = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
street_address = serializers.CharField(
required=True,
allow_blank=False,
validators=[]
)
# We are overriding the `email` field to include unique email validation.
email = serializers.EmailField(
validators=[
UniqueValidator(queryset=Associate.objects.all()),
],
required=True,
allow_blank=False,
)
# All comments are created by our `create` function and not by
# `django-rest-framework`.
# comments = AssociateCommentSerializer(many=True, read_only=True)
# # This is a field used in the `create` function if the user enters a
# # comment. This field is *ONLY* to be used during the POST creation and
# # will be blank during GET.
# extra_comment = serializers.CharField(write_only=True, allow_null=True)
# The skill_sets that this associate belongs to. We will return primary
# keys only. This field is read/write accessible.
skill_sets = serializers.PrimaryKeyRelatedField(many=True, queryset=SkillSet.objects.all(), allow_null=True)
insurance_requirements = serializers.PrimaryKeyRelatedField(many=True, queryset=InsuranceRequirement.objects.all(), allow_null=True)
# assigned_skill_sets = SkillSetListCreateSerializer(many=True, read_only=True)
# Custom formatting of our telephone fields.
fax_number = PhoneNumberField(allow_null=True, required=False)
telephone = PhoneNumberField()
other_telephone = PhoneNumberField(allow_null=True, required=False)
emergency_contact_telephone = PhoneNumberField(allow_null=True, required=False)
emergency_contact_alternative_telephone = PhoneNumberField(allow_null=True, required=False)
is_active = serializers.BooleanField(
write_only=True,
required=True,
)
join_date = serializers.DateField(
required=True,
)
# Attach with our foreign keys.
how_hear = serializers.PrimaryKeyRelatedField(
many=False,
required=True,
allow_null=False,
queryset=HowHearAboutUsItem.objects.all()
)
# Generate the full name of the associate.
full_name = serializers.SerializerMethodField()
address = serializers.SerializerMethodField()
address_url = serializers.SerializerMethodField()
full_address = serializers.SerializerMethodField()
e164_telephone = serializers.SerializerMethodField()
pretty_skill_sets = serializers.SerializerMethodField()
pretty_tags = serializers.SerializerMethodField()
pretty_insurance_requirements = serializers.SerializerMethodField()
pretty_vehicle_types = serializers.SerializerMethodField()
latest_completed_and_paid_order = serializers.SerializerMethodField()
balance_owing_amount = serializers.SerializerMethodField()
created_by = serializers.SerializerMethodField()
last_modified_by = serializers.SerializerMethodField()
score = serializers.FloatField(read_only=True)
avatar_url = serializers.SerializerMethodField()
associate_id = serializers.PrimaryKeyRelatedField(many=False, queryset=Associate.objects.all(), source="id")
# SharedUser
id = serializers.PrimaryKeyRelatedField(many=False, queryset=SharedUser.objects.all(), source="owner.id")
first_name = serializers.CharField(read_only=True, allow_blank=False, source="owner.first_name")
last_name = serializers.CharField(read_only=True, allow_blank=False, source="owner.last_name")
group_id = serializers.SerializerMethodField()
date_joined = serializers.DateTimeField(read_only=True, source="owner.date_joined")
franchise = serializers.PrimaryKeyRelatedField(many=False, queryset=SharedFranchise.objects.all(), source="owner.franchise")
class Meta:
model = Associate
fields = (
# SharedUser
'id',
'first_name',
'last_name',
'group_id',
'date_joined',
'franchise',
# Thing
'associate_id',
'created',
'created_by',
'last_modified',
'last_modified_by',
'description',
# Person
'organization_name',
'organization_type_of',
'organization_type_of_label',
'given_name',
'middle_name',
'last_name',
'birthdate',
'join_date',
'gender',
'description',
'tax_id',
# Misc (Read/Write)
'type_of',
'is_active',
'is_ok_to_email',
'is_ok_to_text',
'hourly_salary_desired',
'limit_special',
'dues_date',
'commercial_insurance_expiry_date',
'auto_insurance_expiry_date',
'wsib_number',
'wsib_insurance_date',
'police_check',
'drivers_license_class',
'vehicle_types', # many-to-many
'how_hear',
'how_hear_other',
'skill_sets', # many-to-many
'tags', # many-to-many
'insurance_requirements', # many-to-many
# Misc (Read Only)
# 'comments',
# 'assigned_skill_sets',
# 'organizations', #TODO: FIX
'full_name',
'address',
'address_url',
'full_address',
'e164_telephone',
'pretty_skill_sets',
'pretty_tags',
'pretty_insurance_requirements',
'pretty_vehicle_types',
'latest_completed_and_paid_order',
'balance_owing_amount',
'score',
'avatar_url',
# # Misc (Write Only)
# 'extra_comment',
# Contact Point
'area_served',
'available_language',
'contact_type',
'email',
'fax_number',
# 'hours_available', #TODO: FIX
'telephone',
'telephone_extension',
'telephone_type_of',
'other_telephone',
'other_telephone_extension',
'other_telephone_type_of',
# Postal Address
'address_country',
'address_locality',
'address_region',
'post_office_box_number',
'postal_code',
'street_address',
'street_address_extra',
# Geo-coordinate
'elevation',
'latitude',
'longitude',
# 'location' #TODO: FIX
# Emergency Contact
'emergency_contact_name',
'emergency_contact_relationship',
'emergency_contact_telephone',
'emergency_contact_alternative_telephone'
)
extra_kwargs = {
"is_ok_to_email": {
"error_messages": {
"invalid": _("Please pick either 'Yes' or 'No' choice.")
}
},
"is_ok_to_text": {
"error_messages": {
"invalid": _("Please pick either 'Yes' or 'No' choice.")
}
},
"hourly_salary_desired": {
"error_messages": {
"min_value": _("Ensure this value is greater than or equal to 0."),
"invalid": _("Please enter a value with no $, such as 20")
}
}
}
def setup_eager_loading(cls, queryset):
""" Perform necessary eager loading of data. """
queryset = queryset.prefetch_related(
'owner',
'created_by',
'last_modified_by',
'skill_sets',
'tags',
'vehicle_types'
'comments',
'insurance_requirements'
)
return queryset
def get_group_id(self, obj):
try:
return obj.owner.groups.first().id
except Exception as e:
print("AssociateProfileSerializer | get_group_id |", e)
return None
def get_full_name(self, obj):
try:
return str(obj)
except Exception as e:
return None
def get_address(self, obj):
try:
return obj.get_postal_address_without_postal_code()
except Exception as e:
return None
def get_address_url(self, obj):
try:
return obj.get_google_maps_url()
except Exception as e:
return None
def get_full_address(self, obj):
try:
return obj.get_postal_address()
except Exception as e:
return None
def get_e164_telephone(self, obj):
"""
Converts the "PhoneNumber" object into a "NATIONAL" format.
See: https://github.com/daviddrysdale/python-phonenumbers
"""
try:
if obj.telephone:
return phonenumbers.format_number(obj.telephone, phonenumbers.PhoneNumberFormat.E164)
else:
return "-"
except Exception as e:
return None
def get_pretty_skill_sets(self, obj):
try:
s = SkillSetListCreateSerializer(obj.skill_sets.all(), many=True)
return s.data
except Exception as e:
return None
def get_pretty_tags(self, obj):
try:
s = TagListCreateSerializer(obj.tags.all(), many=True)
return s.data
except Exception as e:
return None
def get_pretty_insurance_requirements(self, obj):
try:
s = InsuranceRequirementListCreateSerializer(obj.insurance_requirements.all(), many=True)
return s.data
except Exception as e:
return None
def get_pretty_vehicle_types(self, obj):
try:
s = VehicleTypeListCreateSerializer(obj.vehicle_types.all(), many=True)
return s.data
except Exception as e:
return None
def get_latest_completed_and_paid_order(self, obj):
try:
task_item = obj.latest_completed_and_paid_order
return {
'id': task_item.id,
'paid_at': str(task_item.invoice_service_fee_payment_date)
}
except Exception as e:
return {
'id': None,
'paid_at': None
}
def get_balance_owing_amount(self, obj):
try:
return str(obj.balance_owing_amount).replace("C", "")
except Exception as e:
return None
def get_created_by(self, obj):
try:
return str(obj.created_by)
except Exception as e:
return None
def get_last_modified_by(self, obj):
try:
return str(obj.last_modified_by)
except Exception as e:
return None
def get_avatar_url(self, obj):
try:
return obj.avatar_image.image_file.url
except Exception as e:
return None
class TopTenroutesPivotSerializer(serializers.Serializer):
commonroute = serializers.CharField()
cy_revenue = serializers.CharField()
ly_revenue = serializers.FloatField()
vly_revenue = serializers.FloatField()
class myappOutputVectorSerializer(serializers.Serializer):
cumulated_distance = serializers.FloatField()
class Meta:
fields = {'cumulated_distance'}
