Beispiel #1
0
    def set_id_state(self, value: float, s_user):
        old_id_state = None
        old_id_state_id = None
        if self.id_state_id is not None:
            old_id_state = self.id_state
            old_id_state_id = old_id_state.id
        with transaction.atomic():
            self.id_state = TrdOrderState.objects.get(pk=value)

            # чтобы история состояний не ругалась, что нет заказа, когда мы его только создаем, и ставим стартовое состояние
            self.save()
            TrdOrderStateHistory.create_item(self.id, old_id_state_id,
                                             self.id_state.id, s_user)
            if old_id_state is not None and old_id_state.is_write_off_goods(
            ) and not self.id_state.is_write_off_goods():
                # откатываем накладную
                if self.id_act_out is not None:
                    StkAct.roll_back_state(self.id_act_out.id)
            elif (old_id_state is None
                  or not old_id_state.is_write_off_goods()
                  ) and self.id_state.is_write_off_goods():
                # применяем накладную
                self.__sync_with_act()
                StkAct.apply_done_state(self.id_act_out_id)

            self.save()
Beispiel #2
0
    def __sync_with_act(self):
        # создание накладных
        act_out = self.id_act_out

        if act_out is None:
            act_out = StkAct.inset_out_act()
            act_out.s_desc = "Сформирована от \"" + self.get_head_line() + "\""
            act_out.save()
            self.id_act_out = act_out

        if act_out.s_state != StkAct.STATE_REGISTERING:
            raise AppException(
                "Ошибка синхронизации с расходной накладной. Накладная в неверном состоянии"
            )

        # Формирование списка ТМЦ для накладной
        self_gds_out_dict = {}

        def add_qty(id_good, n_qty):
            if id_good in self_gds_out_dict:
                self_gds_out_dict[id_good] = self_gds_out_dict[id_good] + n_qty
            else:
                self_gds_out_dict[id_good] = n_qty

        for order_det in TrdOrderDet.objects.filter(id_order=self):
            add_qty(order_det.id_good_id, order_det.n_qty)

        act_out.apply_det_data(self_gds_out_dict)
Beispiel #3
0
    def roll_back_state(id):
        # откат состояния
        with transaction.atomic():
            shift_result = MnfShiftResult.objects.select_for_update().get(
                pk=id)
            if shift_result.s_state == MnfShiftResult.STATE_REGISTERING:
                raise AppException(
                    "Ошибка отката отчета. Отчет находится в состоянии Оформляется"
                )

            # Откат накладной
            act_out = shift_result.id_act
            act_in = shift_result.id_act_in
            if act_out is not None:
                StkAct.roll_back_state(act_out.id)
            if act_in is not None:
                StkAct.roll_back_state(act_in.id)

            shift_result.s_state = MnfShiftResult.STATE_REGISTERING
            shift_result.save()
Beispiel #4
0
    def apply_form_data(self, changed_items_array, deleted_items_array,
                        changed_materials_array, deleted_materials_array):
        # применение данных из формы редактирования
        with transaction.atomic():
            # блокируем объект
            if self.id is not None:
                old_obj = MnfShiftResult.objects.select_for_update().get(
                    pk=self.id)
                if old_obj.s_state == MnfShiftResult.STATE_DONE:
                    raise AppException(
                        "Ошибка сохранения накладной. Накладная находится в состоянии Выполнен"
                    )

            self.s_state = MnfShiftResult.STATE_DONE
            self.save()

            for det in changed_items_array:
                det.id_shift_result = self
                det.save()

            for det in deleted_items_array:
                det.delete()

            for det in changed_materials_array:
                det.id_shift_result = self
                det.save()

            for det in deleted_materials_array:
                det.delete()

            # синхронизация с накладной
            self.__sync_with_act()
            StkAct.apply_done_state(self.id_act_id)
            StkAct.apply_done_state(self.id_act_in.id)

            self.save()
Beispiel #5
0
    def __sync_with_act(self):
        # создание накладных
        act_out = self.id_act
        act_in = self.id_act_in

        if act_out is None:
            act_out = StkAct.inset_out_act()
            act_out.s_desc = "Сформирована от \"" + self.get_head_line() + "\""
            act_out.save()
            self.id_act = act_out

        if act_out.s_state != StkAct.STATE_REGISTERING:
            raise AppException(
                "Ошибка синхронизации с расходной накладной. Накладная в неверном состоянии"
            )

        if act_in is None:
            act_in = StkAct.inset_in_act()
            act_in.s_desc = "Сформирована от \"" + self.get_head_line() + "\""
            act_in.save()
            self.id_act_in = act_in

        if act_in.s_state != StkAct.STATE_REGISTERING:
            raise AppException(
                "Ошибка синхронизации с приходной накладной. Накладная в неверном состоянии"
            )

        # Формирование списка ТМЦ для накладной
        self_gds_out_dict = {}
        self_gds_in_dict = {}

        def add_qty(dict, id_good, n_qty):
            if id_good in dict:
                dict[id_good] = dict[id_good] + n_qty
            else:
                dict[id_good] = n_qty

        def add_out_qty(id_good, n_qty):
            add_qty(self_gds_out_dict, id_good, n_qty)

        def add_in_qty(id_good, n_qty):
            add_qty(self_gds_in_dict, id_good, n_qty)

        for shift_result_item in MnfShiftResultItems.objects.filter(
                id_shift_result=self):
            # приход
            add_in_qty(shift_result_item.id_item.id_good_id,
                       shift_result_item.n_qty)

            # расход
            for item_det in MnfItemDet.objects.filter(
                    id_item=shift_result_item.id_item):
                add_out_qty(item_det.id_good_id,
                            item_det.n_qty * shift_result_item.n_qty)

        for shift_result_material in MnfShiftResultMaterials.objects.filter(
                id_shift_result=self):
            add_out_qty(shift_result_material.id_good_id,
                        shift_result_material.n_qty)

        # обновление позиций
        act_out.apply_det_data(self_gds_out_dict)
        act_in.apply_det_data(self_gds_in_dict)
Beispiel #6
0
def stk_act_edit(request, pk):
    # редактирование принятой накладной
    StkAct.roll_back_state(pk)
    return HttpResponseRedirect(reverse('stk_act-detail', args=[str(pk)]))
Beispiel #7
0
def insert_out_act(request):
    act = StkAct.inset_out_act()
    return stk_act_detail_by_instance(request, act)