product-inventory-management-after.git

			@@ -28,9 +28,18 @@
			<if test="ew.warnNum != null and ew.warnNum !=''">
			warn_num = #{ew.warnNum},
			</if>
			<if test="ew.lockedQuantity != null and ew.lockedQuantity !=''">
			locked_quantity = locked_quantity + #{ew.lockedQuantity},
			</if>
			update_time = now()
			</set>
			where product_model_id = #{ew.productModelId}
			<if test="ew.batchNo == null">
			and batch_no is null
			</if>
			<if test="ew.batchNo != null">
			and batch_no = #{ew.batchNo}
			</if>
			</update>
			<update id="updateSubtractStockInventory">
			update stock_inventory
			@@ -47,6 +56,12 @@
			update_time = now()
			</set>
			where product_model_id = #{ew.productModelId} and qualitity >= #{ew.qualitity}
			<if test="ew.batchNo == null">
			and batch_no is null
			</if>
			<if test="ew.batchNo != null">
			and batch_no = #{ew.batchNo}
			</if>
			</update>
			<select id="pagestockInventory" resultType="com.ruoyi.stock.dto.StockInventoryDto">
			select si.id,
			@@ -59,6 +74,7 @@
			si.version,
			(si.qualitity - COALESCE(si.locked_quantity, 0)) as un_locked_quantity,
			pm.model,
			si.remark,
			pm.unit,
			p.product_name
			from stock_inventory si
			@@ -69,31 +85,231 @@
			and p.product_name like concat('%',#{ew.productName},'%')
			</if>
			</select>

			<select id="pageListCombinedStockInventory" resultType="com.ruoyi.stock.dto.StockInventoryDto">
			WITH RECURSIVE product_tree AS (
			SELECT id
			FROM product
			WHERE id = #{ew.topParentProductId}

			UNION ALL

			SELECT p.id
			FROM product p
			INNER JOIN product_tree pt ON p.parent_id = pt.id
			)
			select
			GROUP_CONCAT(DISTINCT batch_no ORDER BY batch_no SEPARATOR ',') as batch_no,
			MAX(qualifiedId) as qualifiedId,
			MAX(unQualifiedId) as unQualifiedId,
			SUM(qualifiedQuantity) as qualifiedQuantity,
			SUM(unQualifiedQuantity) as unQualifiedQuantity,
			SUM(qualifiedLockedQuantity) as qualifiedLockedQuantity,
			SUM(unQualifiedLockedQuantity) as unQualifiedLockedQuantity,
			SUM(qualifiedQuantity - qualifiedLockedQuantity - IFNULL(qualifiedPendingOut, 0)) as qualifiedUnLockedQuantity,
			SUM(unQualifiedQuantity - unQualifiedLockedQuantity - IFNULL(unQualifiedPendingOut, 0)) as unQualifiedUnLockedQuantity,
			SUM(IFNULL(qualifiedPendingOut, 0)) as qualifiedPendingOutQuantity,
			SUM(IFNULL(unQualifiedPendingOut, 0)) as unQualifiedPendingOutQuantity,
			product_model_id,
			MAX(create_time) as create_time,
			MAX(update_time) as update_time,
			MAX(warn_num) as warn_num,
			MAX(version) as version,
			model,
			MAX(remark) as remark,
			unit,
			product_name,
			product_id,
			'combined' as stockType
			from (
			select
			si.batch_no,
			si.id as qualifiedId,
			null as unQualifiedId,
			si.qualitity as qualifiedQuantity,
			0 as unQualifiedQuantity,
			COALESCE(si.locked_quantity, 0) as locked_quantity,
			COALESCE(si.locked_quantity, 0) as qualifiedLockedQuantity,
			0 as unQualifiedLockedQuantity,
			si.product_model_id,
			si.create_time,
			si.update_time,
			COALESCE(si.warn_num, 0) as warn_num,
			si.version,
			(si.qualitity - COALESCE(si.locked_quantity, 0)) as un_locked_quantity,
			pm.model,
			si.remark,
			pm.unit,
			p.product_name,
			p.id as product_id,
			(
			select IFNULL(SUM(sor.stock_out_num), 0)
			from stock_out_record sor
			where sor.product_model_id = si.product_model_id
			and (
			(si.batch_no is null and sor.batch_no is null)
			or si.batch_no = sor.batch_no
			)
			and sor.type = '0'
			and sor.approval_status = 0
			) as qualifiedPendingOut,
			0 as unQualifiedPendingOut
			from stock_inventory si
			left join product_model pm on si.product_model_id = pm.id
			left join product p on pm.product_id = p.id

			union all

			select
			su.batch_no,
			null as qualifiedId,
			su.id as unQualifiedId,
			0 as qualifiedQuantity,
			su.qualitity as unQualifiedQuantity,
			COALESCE(su.locked_quantity, 0) as locked_quantity,
			0 as qualifiedLockedQuantity,
			COALESCE(su.locked_quantity, 0) as unQualifiedLockedQuantity,
			su.product_model_id,
			su.create_time,
			su.update_time,
			0 as warn_num,
			su.version,
			(su.qualitity - COALESCE(su.locked_quantity, 0)) as un_locked_quantity,
			pm.model,
			su.remark,
			pm.unit,
			p.product_name,
			p.id as product_id,
			0 as qualifiedPendingOut,
			(
			select IFNULL(SUM(sor.stock_out_num), 0)
			from stock_out_record sor
			where sor.product_model_id = su.product_model_id
			and (
			(su.batch_no is null and sor.batch_no is null)
			or su.batch_no = sor.batch_no
			)
			and sor.type = '1'
			and sor.approval_status = 0
			) as unQualifiedPendingOut
			from stock_uninventory su
			left join product_model pm on su.product_model_id = pm.id
			left join product p on pm.product_id = p.id
			) as combined
			<where>
			<if test="ew.productName != null and ew.productName !=''">
			and combined.product_name in (
			select distinct p.product_name
			from product p
			left join product_model pm on p.id = pm.product_id
			where p.product_name like concat('%',#{ew.productName},'%')
			or pm.model like concat('%',#{ew.productName},'%')
			)
			</if>
			<if test="ew.topParentProductId != null and ew.topParentProductId > 0">
			and combined.product_id in (select id from product_tree)
			</if>
			</where>
			group by
			product_model_id,
			model,
			unit,
			product_name,
			product_id
			</select>

			<select id="listStockInventoryExportData" resultType="com.ruoyi.stock.execl.StockInventoryExportData">
			select si.qualitity,
			WITH RECURSIVE product_tree AS (
			SELECT id
			FROM product
			WHERE id = #{ew.topParentProductId}

			UNION ALL

			SELECT p.id
			FROM product p
			INNER JOIN product_tree pt ON p.parent_id = pt.id
			)
			select
			SUM(qualifiedQuantity) as qualifiedQuantity,
			SUM(unQualifiedQuantity) as unQualifiedQuantity,
			SUM(qualifiedLockedQuantity) as qualifiedLockedQuantity,
			SUM(unQualifiedLockedQuantity) as unQualifiedLockedQuantity,
			model,
			unit,
			product_name,
			batch_no,
			MAX(warn_num) as warn_num,
			MAX(remark) as remark,
			MAX(update_time) as update_time
			from (
			select
			si.qualitity as qualifiedQuantity,
			0 as unQualifiedQuantity,
			COALESCE(si.locked_quantity, 0) as qualifiedLockedQuantity,
			0 as unQualifiedLockedQuantity,
			si.product_model_id,
			si.create_time,
			si.update_time,
			si.batch_no,
			COALESCE(si.warn_num, 0) as warn_num,
			si.remark,
			pm.model,
			pm.unit,
			p.product_name,
			p.id as product_id
			from stock_inventory si
			left join product_model pm on si.product_model_id = pm.id
			left join product p on pm.product_id = p.id

			union all

			select
			0 as qualifiedQuantity,
			su.qualitity as unQualifiedQuantity,
			0 as qualifiedLockedQuantity,
			COALESCE(su.locked_quantity, 0) as unQualifiedLockedQuantity,
			su.product_model_id,
			su.create_time,
			su.update_time,
			0 as warn_num,
			su.batch_no,
			su.remark,
			pm.model,
			pm.unit,
			p.product_name,
			p.id as product_id
			from stock_uninventory su
			left join product_model pm on su.product_model_id = pm.id
			left join product p on pm.product_id = p.id
			) as combined
			<where>
			<if test="ew.productName != null and ew.productName !=''">
			and combined.product_name in (
			select distinct p.product_name
			from product p
			left join product_model pm on p.id = pm.product_id
			where p.product_name like concat('%',#{ew.productName},'%') or pm.model like concat('%',#{ew.productName},'%')
			)
			</if>
			<if test="ew.topParentProductId != null and ew.topParentProductId > 0">
			and combined.product_id in (select id from product_tree)
			</if>
			</where>
			group by product_model_id, model, unit, product_name,batch_no
			</select>
			<select id="stockInventoryPage" resultType="com.ruoyi.stock.dto.StockInRecordDto">
			select sir.*,si.qualitity as current_stock,
			pm.model,
			pm.unit,
			p.product_name,
			si.remark,
			si.update_time
			from stock_inventory si
			left join product_model pm on si.product_model_id = pm.id
			left join product p on pm.product_id = p.id
			where 1 = 1
			<if test="ew.productName != null and ew.productName !=''">
			and p.product_name like concat('%',#{ew.productName},'%')
			</if>
			</select>
			<select id="stockInventoryPage" resultType="com.ruoyi.stock.dto.StockInRecordDto">
			select sir.*,si.qualitity,
			pm.model,
			pm.unit,
			p.product_name
			su.nick_name as create_by
			from
			stock_in_record sir
			left join stock_inventory si on sir.product_model_id = si.product_model_id
			left join product_model pm on sir.product_model_id = pm.id
			left join product p on pm.product_id = p.id
			left join sys_user su on sir.create_user = su.user_id
			<where>
			<if test="ew.reportDate != null">
			and sir.create_time >= #{ew.reportDate}
			@@ -178,5 +394,233 @@
			pm.unit,
			p.product_name
			</select>
			<select id="selectTotal" resultType="java.math.BigDecimal">
			select ifnull(sum(qualitity), 0)
			from stock_inventory
			</select>

			<select id="selectTotalByDate" resultType="java.math.BigDecimal">
			select IFNULL(sum(qualitity), 0)
			from stock_inventory
			where create_time >= #{now}
			and create_time < DATE_ADD(#{now}, INTERVAL 1 DAY)
			</select>

			<select id="selectStorageProductCountByDate" resultType="int">
			SELECT SUM(total_count)
			FROM (SELECT COUNT(*) as total_count
			FROM stock_inventory
			WHERE create_time >= #{startDate}
			AND create_time <= #{endDate}
			UNION ALL
			SELECT COUNT(*) as total_count
			FROM stock_uninventory
			WHERE create_time >= #{startDate}
			AND create_time <= #{endDate}) AS combined_counts
			</select>

			<select id="selectDailyStockInCounts" resultType="java.util.Map">
			SELECT DATE(sir.create_time) AS date,
			SUM(sir.stock_in_num) AS count
			FROM stock_in_record sir
			JOIN product_model pm ON sir.product_model_id = pm.id
			JOIN product p ON pm.product_id = p.id
			WHERE (p.parent_id = #{rootCategoryId} OR p.id = #{rootCategoryId})
			AND sir.create_time >= #{startDate}
			AND sir.create_time <= #{endDate}
			GROUP BY DATE(sir.create_time)
			ORDER BY DATE(sir.create_time) ASC
			</select>

			<select id="selectDailyStockOutCounts" resultType="java.util.Map">
			SELECT DATE(sor.create_time) AS date,
			SUM(sor.stock_out_num) AS count
			FROM stock_out_record sor
			JOIN product_model pm ON sor.product_model_id = pm.id
			JOIN product p ON pm.product_id = p.id
			WHERE (p.parent_id = #{rootCategoryId} OR p.id = #{rootCategoryId})
			AND sor.create_time >= #{startDate}
			AND sor.create_time <= #{endDate}
			GROUP BY DATE(sor.create_time)
			ORDER BY DATE(sor.create_time) ASC
			</select>

			<select id="selectPendingOutQuantity" resultType="java.math.BigDecimal">
			SELECT IFNULL(SUM(sor.stock_out_num), 0)
			FROM stock_out_record sor
			WHERE sor.product_model_id = #{productModelId}
			AND (sor.batch_no = #{batchNo} OR (#{batchNo} IS NULL AND sor.batch_no IS NULL))
			AND sor.type = #{type}
			AND sor.approval_status IN (0, 3)
			</select>

			<select id="listSelectableBatchNoByProductModelIds" resultType="com.ruoyi.stock.pojo.StockInventory">
			select distinct si.product_model_id,
			si.batch_no
			from stock_inventory si
			where si.product_model_id in
			<foreach collection="productModelIds" item="productModelId" open="(" separator="," close=")">
			#{productModelId}
			</foreach>
			and si.batch_no is not null
			and si.batch_no != ''
			and (si.qualitity - ifnull(si.locked_quantity, 0)) > 0
			order by si.product_model_id, si.batch_no
			</select>
			<select id="getByModelId" resultType="com.ruoyi.stock.pojo.StockInventory">
			select si.id, si.batch_no, si.locked_quantity, (si.qualitity - IFNULL(sd.qualitity, 0)) as qualitity
			from stock_inventory si
			left join (
			select spd.stock_inventory_id, sum(spd.quantity) as qualitity
			from shipping_product_detail spd
			where exists (
			select 1
			from stock_out_record sor
			where sor.record_id = spd.shipping_info_id
			and sor.record_type = '13'
			and sor.type = '0'
			and sor.approval_status in (0, 3)
			and sor.product_model_id = spd.product_model_id
			and (sor.batch_no = spd.batch_no or (sor.batch_no is null and spd.batch_no is null))
			)
			group by spd.stock_inventory_id
			) as sd on sd.stock_inventory_id = si.id
			where si.product_model_id = #{productModelId}
			and si.qualitity > IFNULL(sd.qualitity, 0)
			</select>

			<select id="getBatchNoQty" resultType="com.ruoyi.stock.dto.StockInventoryDto">
			select
			batch_no,
			MAX(qualifiedId) as qualifiedId,
			MAX(unQualifiedId) as unQualifiedId,

			SUM(qualifiedQuantity) as qualifiedQuantity,
			SUM(unQualifiedQuantity) as unQualifiedQuantity,

			SUM(qualifiedLockedQuantity) as qualifiedLockedQuantity,
			SUM(unQualifiedLockedQuantity) as unQualifiedLockedQuantity,

			SUM(IFNULL(qualifiedPendingOut, 0)) as qualifiedPendingOutQuantity,
			SUM(IFNULL(unQualifiedPendingOut, 0)) as unQualifiedPendingOutQuantity,

			SUM(qualifiedQuantity - qualifiedLockedQuantity - IFNULL(qualifiedPendingOut, 0)) as qualifiedUnLockedQuantity,
			SUM(unQualifiedQuantity - unQualifiedLockedQuantity - IFNULL(unQualifiedPendingOut, 0)) as unQualifiedUnLockedQuantity,

			product_model_id,
			model,
			unit,
			product_name,
			product_id,

			MAX(create_time) as create_time,
			MAX(update_time) as update_time,
			MAX(warn_num) as warn_num,
			MAX(version) as version,
			MAX(remark) as remark,

			'combined' as stockType
			from (
			select
			si.batch_no,
			si.id as qualifiedId,
			null as unQualifiedId,

			si.qualitity as qualifiedQuantity,
			0 as unQualifiedQuantity,

			COALESCE(si.locked_quantity, 0) as qualifiedLockedQuantity,
			0 as unQualifiedLockedQuantity,

			si.product_model_id,
			pm.model,
			pm.unit,
			p.product_name,
			p.id as product_id,

			si.create_time,
			si.update_time,
			COALESCE(si.warn_num, 0) as warn_num,
			si.version,
			si.remark,

			(
			select IFNULL(SUM(sor.stock_out_num), 0)
			from stock_out_record sor
			where sor.product_model_id = si.product_model_id
			and (
			(si.batch_no is null and sor.batch_no is null)
			or si.batch_no = sor.batch_no
			)
			and sor.type = '0'
			and sor.approval_status = 0
			) as qualifiedPendingOut,

			0 as unQualifiedPendingOut
			from stock_inventory si
			left join product_model pm on si.product_model_id = pm.id
			left join product p on pm.product_id = p.id

			union all

			select
			su.batch_no,
			null as qualifiedId,
			su.id as unQualifiedId,

			0 as qualifiedQuantity,
			su.qualitity as unQualifiedQuantity,

			0 as qualifiedLockedQuantity,
			COALESCE(su.locked_quantity, 0) as unQualifiedLockedQuantity,

			su.product_model_id,
			pm.model,
			pm.unit,
			p.product_name,
			p.id as product_id,

			su.create_time,
			su.update_time,
			0 as warn_num,
			su.version,
			su.remark,

			0 as qualifiedPendingOut,

			(
			select IFNULL(SUM(sor.stock_out_num), 0)
			from stock_out_record sor
			where sor.product_model_id = su.product_model_id
			and (
			(su.batch_no is null and sor.batch_no is null)
			or su.batch_no = sor.batch_no
			)
			and sor.type = '1'
			and sor.approval_status = 0
			) as unQualifiedPendingOut
			from stock_uninventory su
			left join product_model pm on su.product_model_id = pm.id
			left join product p on pm.product_id = p.id
			) as combined
			<where>
			<if test="ew.productModelId != null and ew.productModelId > 0">
			and combined.product_model_id = #{ew.productModelId}
			</if>

			<if test="ew.productId != null and ew.productId > 0">
			and combined.product_id = #{ew.productId}
			</if>
			</where>
			group by
			batch_no,
			product_model_id,
			model,
			unit,
			product_name,
			product_id
			order by
			batch_no
			</select>

			</mapper>