Reagent/code/api/dictionary.py

from pypinyin import lazy_pinyin, Style
from sqlalchemy import or_

from utils.BatchCode import GetGroupCode
from utils.apiDoc import *
from utils.dictionaryHelper import *
from utils.listHelper import list2String


@dictionary.route('/positionList')
class PositionList(Resource):
    @staticmethod
    def get():
        return GetList(ReagtPosition, ReagtPosition.PositionId, ReagtPosition.Position,
                       ReagtPosition.PositionCode, request.args)


@dictionary.route('/positionChange')
class PositionChange(Resource):
    @staticmethod
    def post():
        return StatusChange(ReagtPosition, request.args['PositionId'],
                            request.args, ReagtPosition.PositionId, ReagtStock.Position, request.args['Position'])


@dictionary.route('/positionAdd')
class PositionAdd(Resource):
    @staticmethod
    def post():
        data = Dict2Obj(request.json)
        return DictionaryAdd(ReagtPosition.query.filter_by(Position=data.Position).first(),
                             ReagtPosition(Position=data.Position, Using=data.Using,
                                           PositionCode=list2String(lazy_pinyin(data.Position,
                                                                                style=Style.FIRST_LETTER))))


# @dictionary.route('/positionEdit')
# class PositionEdit(Resource):
#     @staticmethod
#     def post():
#         if ReagtPosition.query.filter_by(Position=request.args['Position']).first() is not None:
#             return SuccessResponse(ResultCode.DATA_ALREADY_EXISTED, None, None)
#         positionEntity = ReagtPosition.query.filter_by(PositionId=request.args['PositionId']).first()
#         db.session.query(ReagtStock).filter(ReagtStock.Position == positionEntity.Position)\
#             .update({ReagtStock.Position: request.args['Position']})
#         positionEntity.Position = request.args['Position']
#         db.session.commit()
#         return SuccessResponse(ResultCode.SUCCESS, None, None)


@dictionary.route('/supplierList')
class SupplierList(Resource):
    @staticmethod
    def get():
        return GetList(ReagtSupplier, ReagtSupplier.SupplierId, ReagtSupplier.SupplierName,
                       ReagtSupplier.SupplierCode, request.args)


@dictionary.route('/supplierChange')
class SupplierChange(Resource):
    @staticmethod
    def post():
        return StatusChange(ReagtSupplier, request.args['SupplierId'],
                            request.args, ReagtSupplier.SupplierId, ReagtStock.SupplierName,
                            request.args['SupplierName'])


@dictionary.route('/supplierAdd')
class SupplierAdd(Resource):
    @staticmethod
    def post():
        data = Dict2Obj(request.json)
        return DictionaryAdd(ReagtSupplier.query.filter_by(SupplierName=data.SupplierName).first(),
                             ReagtSupplier(SupplierName=data.SupplierName, Using=data.Using,
                                           SupplierCode=list2String(lazy_pinyin(data.SupplierName,
                                                                                style=Style.FIRST_LETTER))))


@dictionary.route('/groupAdd')
class GroupAdd(Resource):
    @staticmethod
    def post():
        data = Dict2Obj(request.json)
        return DictionaryAdd(ReagtGroup.query.filter_by(GroupName=data.GroupName).first(),
                             ReagtGroup(GroupName=data.GroupName, GroupCode=GetGroupCode()))


@dictionary.route('/groupDelete')
class GroupDelete(Resource):
    @staticmethod
    def post():
        data = Dict2Obj(request.json)
        reagent = ReagtReagent.query.filter_by(GroupName=data.GroupName).all()
        if len(reagent) > 0:
            return BadResponse(ResultCode.GROUP_INFO_IS_USING, None, None)
        group = ReagtGroup.query.filter_by(GroupName=data.GroupName).first()
        db.session.delete(group)
        db.session.commit()
        return SuccessResponse(ResultCode.SUCCESS, None, None)


@dictionary.route('/groupList')
class GroupList(Resource):
    @staticmethod
    def get():
        return GetList(ReagtGroup, ReagtGroup.GroupId, ReagtGroup.GroupName, ReagtGroup.GroupCode,
                       request.args, is_all=True)


@dictionary.route('/reportItemList')
class ReportItemList(Resource):
    @staticmethod
    def get():
        reportItem = db.session.query(ReagtReagent.ReportItem).group_by(ReagtReagent.ReportItem)\
            .filter(ReagtReagent.ReportItem != None).all()
        list_result = []
        for item in reportItem:
            list_result.append(item[0])
        return SuccessResponse(ResultCode.SUCCESS, list_result, None)


@dictionary.route('/groupReagent')
class GroupReagent(Resource):
    @staticmethod
    def get():
        data = request.args
        filter_item = ReagtReagent.query.filter(ReagtReagent.GroupName == data['groupName'])\
            .order_by(ReagtReagent.ReagentId.desc())
        if data.get('query') is not None:
            filter_item = ReagtReagent.query.filter(
                or_(ReagtReagent.Name.contains(data['query']),
                    ReagtReagent.PinYinCode.contains(data['query']))) \
                .filter(ReagtReagent.GroupName == data['groupName']) \
                .order_by(ReagtReagent.ReagentId.desc())
        return SuccessResponse(ResultCode.SUCCESS, {'totalNumber': filter_item.count(),
                                                    'list': db_page_entity(filter_item, data, 10)}, None)








# @dictionary.route('/supplierEdit')
# class SupplierEdit(Resource):
#     @staticmethod
#     def post():
#         if ReagtSupplier.query.filter_by(SupplierName=request.args['SupplierName']).first() is not None:
#             return SuccessResponse(ResultCode.DATA_ALREADY_EXISTED, None, None)
#         supplierEntity = ReagtSupplier.query.filter_by(SupplierId=request.args['SupplierId']).first()
#         db.session.query(ReagtStock).filter(ReagtStock.SupplierName == supplierEntity.SupplierName)\
#             .update({ReagtStock.SupplierName: request.args['SupplierName']})
#         supplierEntity.SupplierName = request.args['SupplierName']
#         db.session.commit()
#         return SuccessResponse(ResultCode.SUCCESS, None, None)