Index: ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/action/RecyclingApplicationAction.java
===================================================================
diff -u -r17512 -r17530
--- ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/action/RecyclingApplicationAction.java	(.../RecyclingApplicationAction.java)	(revision 17512)
+++ ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/action/RecyclingApplicationAction.java	(.../RecyclingApplicationAction.java)	(revision 17530)
@@ -26,6 +26,7 @@
 import com.forgon.disinfectsystem.project.service.ProjectManager;
 import com.forgon.disinfectsystem.recyclingapplication.service.InvoicePlanManager;
 import com.forgon.disinfectsystem.recyclingapplication.service.RecyclingApplicationManager;
+import com.forgon.disinfectsystem.recyclingapplication.vo.ReturnGoodVo;
 import com.forgon.disinfectsystem.tousse.imagefilemanager.service.ImageFileManager;
 import com.forgon.disinfectsystem.tousse.materialdefinition.service.MaterialDefinitionManager;
 import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseDefinitionHelper;
@@ -53,6 +54,7 @@
 import net.sf.json.util.CycleDetectionStrategy;
 import net.sf.json.util.PropertyFilter;
 
+import org.apache.commons.collections.MapUtils;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.Predicate;
 import org.apache.commons.collections4.Transformer;
@@ -478,31 +480,15 @@
 			JSONObject jsonObject = saveRecyclingApplication(recyclingApplication, srcTousseItemVoList);
 			return jsonObject;
 		}
-		
-		Collection<InvoicePlan> borrowApplications = recyclingApplicationManager
-				.getUnreturnBorrowApplication(recyclingApplication.getDepartCoding());
-		Map<String, Integer> restApplyTousses = convertVosToMap(srcTousseItemVoList);	// 剩余申请物品
-		MultiValueMap<String, Integer> actualAllReturnTousses = new MultiValueMap<>();	// 实际归还的物品
-		// 创建还物单
-		for (InvoicePlan borrowApplication : borrowApplications) {
-			// 每次循环，传入归还前的剩余申请物品作为可归还物品
-			// 传入actualReturnTousses作为输出参数，此方法会把实际归还的物品放入map中
-			// 返回值为归还后的剩余申请物品
-			Map<String, Integer> actualReturnTousses = new HashMap<>();
-			restApplyTousses = recyclingApplicationManager
-					.createReturnApplication(recyclingApplication.getApplicant(),
-							borrowApplication.getId(), restApplyTousses,
-							actualReturnTousses);
-			actualAllReturnTousses.putAll(actualReturnTousses);
-			if (restApplyTousses.isEmpty())
-				break;
-		}
 
+		ReturnGoodVo returnGoodVo = recyclingApplicationManager.handleReturnGoodByApplication(this.convertVosToMap(srcTousseItemVoList), recyclingApplication);
+		MultiValueMap<String, Integer> actualAllReturnTousses = returnGoodVo.getActualAllReturnTousses();
+		Map<String, Integer> restApplyTousses = returnGoodVo.getRestApplyTousses();
 		// 添加备注
-		appendReturnedRemark(recyclingApplication, actualAllReturnTousses,
-				restApplyTousses);
+		appendReturnedRemark(recyclingApplication, actualAllReturnTousses, restApplyTousses);
 
-		if (restApplyTousses.isEmpty()) {
+		if (recyclingApplicationManager.isAllReturn(restApplyTousses)) {
+		// if (restApplyTousses.isEmpty()) {
 			// 若全部物品转换为还物单，则保存原申请单的状态为已终止
 			saveRecyclingApplication(recyclingApplication, srcTousseItemVoList);
 			
Index: ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManagerImpl.java
===================================================================
diff -u -r17512 -r17530
--- ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManagerImpl.java	(.../RecyclingApplicationManagerImpl.java)	(revision 17512)
+++ ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManagerImpl.java	(.../RecyclingApplicationManagerImpl.java)	(revision 17530)
@@ -21,6 +21,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import com.forgon.disinfectsystem.recyclingapplication.vo.ReturnGoodVo;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
 import net.sf.json.JsonConfig;
@@ -3414,7 +3415,87 @@
 		return exist;
 	}
 
+	@Override
+	public boolean isAllReturn(Map<String, Integer> map) {
+		for (Entry<String, Integer> it : map.entrySet()) {
+			if (it.getValue() != 0){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public ReturnGoodVo handleReturnGoodByApplication(Map<String, Integer> restApplyTousses, RecyclingApplication recyclingApplication) {
+		Collection<InvoicePlan> borrowApplications = this.getUnreturnBorrowApplication(recyclingApplication.getDepartCoding());
+		// 实际归还的物品
+		MultiValueMap<String, Integer> actualAllReturnTousses = new MultiValueMap<>();
+		// 创建还物单
+		/*for (InvoicePlan borrowApplication : borrowApplications) {
+			// 每次循环，传入归还前的剩余申请物品作为可归还物品
+			// 传入actualReturnTousses作为输出参数，此方法会把实际归还的物品放入map中
+			// 返回值为归还后的剩余申请物品
+			Map<String, Integer> actualReturnTousses = new HashMap<>();
+			restApplyTousses = recyclingApplicationManager
+					.createReturnApplication(recyclingApplication.getApplicant(),
+							borrowApplication.getId(), restApplyTousses,
+							actualReturnTousses);
+			actualAllReturnTousses.putAll(actualReturnTousses);
+			if (restApplyTousses.isEmpty())
+				break;
+		}*/
+		ReturnGoodVo returnGoodVo = new ReturnGoodVo();
+		for (InvoicePlan borrowApplication : borrowApplications) {
+			Map<String, Integer> canReturnAmount = this.getCanReturnAmount(borrowApplication.getId());
+			if (org.apache.commons.collections.MapUtils.isEmpty(canReturnAmount)) {
+				continue;
+			}
+			logger.info("通过申请单来归还物品开始...");
+			logger.info("借物单:" + borrowApplication.getId() + "剩余归还的数量是-" + canReturnAmount);
+			logger.info("这次申请归还的物品数量是:" + restApplyTousses);
+			//归还的物品的数量,在归还前重新计算一下，因为有可能这次申请的数量大于要归还的数量(createReturnApplication方法中当归还的数量大于最大可归还的数量时会报错),如果大于则归还数量是最大的待归还数量,如果小于则归还数量是这次申请的数量
+			Map<String, Integer> applyTousses = this.calculateBeforeReturn(restApplyTousses, canReturnAmount);
+			logger.info("这次归还物品数量是:" + applyTousses);
+			Map<String, Integer> actualReturnTousses = new HashMap<>();
+			this.createReturnApplication("admin", borrowApplication.getId(), applyTousses, actualReturnTousses);
+			actualAllReturnTousses.putAll(actualReturnTousses);
+			logger.info("这次实际归还了的数量是" + actualAllReturnTousses);
+			logger.info("剩余的申请物品的数量是" + restApplyTousses);
+		}
+		returnGoodVo.setActualAllReturnTousses(actualAllReturnTousses);
+		returnGoodVo.setRestApplyTousses(restApplyTousses);
+		return returnGoodVo;
+	}
+
 	/**
+	 * 在归还前根据待归还数量和申请数量来重新计算
+	 * @param restApplyTousses 申请的物品数量
+	 * @param canReturnAmount 待归还数量
+	 * @return 返回这次归还的数量
+	 */
+	private Map<String, Integer> calculateBeforeReturn(Map<String, Integer> restApplyTousses, Map<String, Integer> canReturnAmount) {
+		Map<String, Integer> applyTousses = new HashMap<>();
+		//用这次申请的物品和剩余可归还物品作比较
+		for (Entry<String, Integer> map : canReturnAmount.entrySet()) {
+            String key = map.getKey();
+            int amount = Math.subtractExact(map.getValue(), restApplyTousses.get(key));
+            if (amount < 0) {
+                //如果这次申请的数量大于可归还的数量(即申请单的物品数量>借物单的数量),设置归还的数量为最大可归还数量
+                applyTousses.put(key, map.getValue());
+                //重新设置剩余申请归还数量
+                restApplyTousses.put(key, Math.subtractExact(restApplyTousses.get(key), map.getValue()));
+            }
+            else {
+                // 如果这次申请数量小于等于可归还的数量(即申请单的物品数量<=借物单的数量),设置归还的数量为这次申请归还的数量
+                applyTousses.put(key, restApplyTousses.get(key));
+                //因为已经全部把申请归还数量去还了，所以这里剩余申请归还数量是0
+                restApplyTousses.put(key, 0);
+            }
+        }
+		return applyTousses;
+	}
+
+	/**
 	 * 创建“申请还物单”<br/>
 	 * applyReturnTousses参数为申请归还的物品<br/>
 	 * 传入actualReturnTousses作为输出参数，此方法会把实际归还的物品放入map中<br/>
@@ -3539,8 +3620,7 @@
 				restReturnTousses.put(touseName, restReturnAmount);
 			}
 		}*/
-		Map<String, Integer> restReturnTousses = this.calculateRestAmount(convertAppAmount, applyReturnTousses,unreturnTousseMap);
-		return restReturnTousses;
+		return this.calculateRestAmount(convertAppAmount, applyReturnTousses,unreturnTousseMap);
 	}
 
 	/**
Index: ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestRecyclingApplication.java
===================================================================
diff -u -r16723 -r17530
--- ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestRecyclingApplication.java	(.../TestRecyclingApplication.java)	(revision 16723)
+++ ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestRecyclingApplication.java	(.../TestRecyclingApplication.java)	(revision 17530)
@@ -71,7 +71,7 @@
 	private DiposableGoodsManager diposableGoodsManager;
 
 
-	private void initCustomGoods(){
+	protected void initCustomGoods(){
 		
 		Collection<TousseItemVo> applyItemVos = new ArrayList<TousseItemVo>();
 		appendToCollection(applyItemVos, "注射器[20ML]", 100 , "一次性物品", "否", 0);
Index: ssts-web/src/test/java/test/forgon/disinfectsystem/dataProvider/application/BorrowAppDataProvider.java
===================================================================
diff -u -r17081 -r17530
--- ssts-web/src/test/java/test/forgon/disinfectsystem/dataProvider/application/BorrowAppDataProvider.java	(.../BorrowAppDataProvider.java)	(revision 17081)
+++ ssts-web/src/test/java/test/forgon/disinfectsystem/dataProvider/application/BorrowAppDataProvider.java	(.../BorrowAppDataProvider.java)	(revision 17530)
@@ -5,7 +5,11 @@
 import com.forgon.disinfectsystem.entity.useRecord.UseRecord;
 import org.testng.annotations.DataProvider;
 import test.forgon.disinfectsystem.dataProvider.UseRecord.UseRecordDataProvider;
+import test.forgon.disinfectsystem.dataProvider.tousseDefinition.TousseDefinitionDataProvider;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * @author zhonghaowen
  * @apiNote 借物单数据驱动提供类
@@ -44,4 +48,24 @@
         UseRecord useRecord = UseRecordDataProvider.createUseRecord();
         return new Object[][]{{tousseApplication, useRecord}};
     }
+
+    /**
+     * 通过器械包申请单来归还借物单的物品数据驱动
+     * @return
+     */
+    @DataProvider(name = "returnByApplicationProvider")
+    public static Object[][] returnByApplicationProvider() {
+        Map<String, Integer> applyGoodMap1 = new HashMap<>();
+        applyGoodMap1.put(TousseDefinitionDataProvider.Test开胸包, 1);
+        Map<String, Integer> applyGoodMap2 = new HashMap<>();
+        applyGoodMap2.put(TousseDefinitionDataProvider.Test开胸包, 2);
+        Map<String, Integer> applyGoodMap3 = new HashMap<>();
+        applyGoodMap3.put(TousseDefinitionDataProvider.Test开胸包, 3);
+        //构造借物申请单和器械包申请单的相关物品
+        return new Object[][]{
+                {createApplicationByParam(InvoicePlan.TYPE_BORROWINGSINGLE), applyGoodMap1}
+                , {createApplicationByParam(InvoicePlan.TYPE_BORROWINGSINGLE), applyGoodMap2}
+                , {createApplicationByParam(InvoicePlan.TYPE_BORROWINGSINGLE), applyGoodMap3}
+        };
+    }
 }
Index: ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/vo/ReturnGoodVo.java
===================================================================
diff -u
--- ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/vo/ReturnGoodVo.java	(revision 0)
+++ ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/vo/ReturnGoodVo.java	(revision 17530)
@@ -0,0 +1,47 @@
+package com.forgon.disinfectsystem.recyclingapplication.vo;
+
+import org.apache.commons.collections4.map.MultiValueMap;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author zhonghaowen
+ * @apiNote 申请单归还物品vo
+ * @since 2017-03-28
+ */
+public class ReturnGoodVo {
+
+    /**
+     * 这次申请的相关物品
+     */
+    private Map<String, Integer> restApplyTousses = new HashMap<>();
+    /**
+     * 实际归还的物品
+     */
+    private MultiValueMap<String, Integer> actualAllReturnTousses = new MultiValueMap<>();
+
+    public Map<String, Integer> getRestApplyTousses() {
+        return restApplyTousses;
+    }
+
+    public void setRestApplyTousses(Map<String, Integer> restApplyTousses) {
+        this.restApplyTousses = restApplyTousses;
+    }
+
+    public MultiValueMap<String, Integer> getActualAllReturnTousses() {
+        return actualAllReturnTousses;
+    }
+
+    public void setActualAllReturnTousses(MultiValueMap<String, Integer> actualAllReturnTousses) {
+        this.actualAllReturnTousses = actualAllReturnTousses;
+    }
+
+    @Override
+    public String toString() {
+        return "ReturnGoodVo{" +
+                "restApplyTousses=" + restApplyTousses +
+                ", actualAllReturnTousses=" + actualAllReturnTousses +
+                '}';
+    }
+}
Index: ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManager.java
===================================================================
diff -u -r17081 -r17530
--- ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManager.java	(.../RecyclingApplicationManager.java)	(revision 17081)
+++ ssts-recyclingapplication/src/main/java/com/forgon/disinfectsystem/recyclingapplication/service/RecyclingApplicationManager.java	(.../RecyclingApplicationManager.java)	(revision 17530)
@@ -8,6 +8,7 @@
 
 import com.forgon.directory.model.OrgUnit;
 
+import com.forgon.disinfectsystem.recyclingapplication.vo.ReturnGoodVo;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
 
@@ -231,4 +232,20 @@
 	 * @param borrowId 借物单id
 	 */
 	void returnApplication(Long borrowId);
+
+
+	/**
+	 * 判断借物单的物品是否全部归还
+	 * @param map 借物单物品剩下可归还物品的map
+	 * @return
+	 */
+	boolean isAllReturn(Map<String, Integer> map);
+
+	/**
+	 * 处理通过申请单来归还物品
+	 * @param restApplyTousses 申请的物品
+	 * @param recyclingApplication 该申请单
+	 * @return {@link ReturnGoodVo}
+	 */
+	ReturnGoodVo handleReturnGoodByApplication(Map<String, Integer> restApplyTousses, RecyclingApplication recyclingApplication);
 }
Index: ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestTousseRecyclingApplication.java
===================================================================
diff -u
--- ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestTousseRecyclingApplication.java	(revision 0)
+++ ssts-web/src/test/java/test/forgon/disinfectsystem/application/TestTousseRecyclingApplication.java	(revision 17530)
@@ -0,0 +1,149 @@
+package test.forgon.disinfectsystem.application;
+
+import com.forgon.disinfectsystem.entity.invoicemanager.InvoicePlan;
+import com.forgon.disinfectsystem.entity.recyclingapplication.RecyclingApplication;
+import com.forgon.disinfectsystem.entity.tousseitem.TousseItem;
+import com.forgon.disinfectsystem.recyclingapplication.service.InvoicePlanManager;
+import com.forgon.disinfectsystem.recyclingapplication.service.RecyclingApplicationManager;
+import com.forgon.disinfectsystem.vo.TousseItemVo;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.orm.hibernate4.HibernateTemplate;
+import org.testng.annotations.Test;
+import test.forgon.disinfectsystem.dataProvider.application.ApplicationDataProvider;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+
+/**
+ * @author zhonghaowen
+ * @apiNote 器械包申请单
+ * @since 2017-03-27
+ */
+public class TestTousseRecyclingApplication extends TestRecyclingApplication {
+
+    @Autowired
+    private RecyclingApplicationManager recyclingApplicationManager;
+
+    @Autowired
+    private InvoicePlanManager invoicePlanManager;
+
+
+    private void prepareData() {
+        initCSSDData();
+        initCustomGoods();
+        makeActiveUser("oruser1");
+    }
+
+
+    /**
+     * 创建一张器械包申请单，然后更新里面的物品，最后删除这张申请单
+     */
+    @Test
+    public void testTousseRecyclingApplicationCRUD() {
+        this.prepareData();
+        HibernateTemplate ht = objectDao.getHt();
+        RecyclingApplication recyclingApplication = this.createTousseRecyclingApplication();
+        //断言申请单的结果
+        RecyclingApplication result = this.assertTousseRecyclingApplication(recyclingApplication, 3, InvoicePlan.RECYCLINGSTATUS_AWAITRECYCLE);
+        Long id = recyclingApplication.getId();
+        //申请单新增眼垫,探针数量改成1
+        Collection<TousseItemVo> modifyApplyItemVos = new ArrayList<>();
+        appendToCollection(modifyApplyItemVos, "探针", 1, "器械包", "是", result.getApplicationItems().get(0).getId());
+        appendToCollection(modifyApplyItemVos, "眼垫", 6, "器械包", "是", 0);
+        //更新申请单
+        recyclingApplicationManager.saveRecyclingApplication(recyclingApplication, modifyApplyItemVos, true);
+        result = ht.get(RecyclingApplication.class, id);
+        assertNotNull(result);
+        assertEquals(InvoicePlan.RECYCLINGSTATUS_AWAITRECYCLE, result.getRecyclingStatus());
+        List<TousseItem> newItemList = result.getApplicationItems();
+        assertNotNull(newItemList);
+        assertEquals(4, newItemList.size());
+        //查找探针且探针的数量为1
+        Collection<TousseItem> select = CollectionUtils.select(newItemList, tousseItem -> "探针".equals(tousseItem.getTousseName()) && 1 == tousseItem.getAmount());
+        assertEquals(select.size(), 1);
+        //删除该申请单
+        recyclingApplicationManager.deleteRecyclingApplication(id.toString());
+        result = ht.get(RecyclingApplication.class, id);
+        assertNull(result);
+    }
+
+
+    /**
+     * 终止器械包申请单
+     */
+    @Test
+    public void testTousseRecyclingApplicationCancel() {
+        this.prepareData();
+        RecyclingApplication recyclingApplication = this.createTousseRecyclingApplication();
+        //断言申请单的结果
+        this.assertTousseRecyclingApplication(recyclingApplication, 3, InvoicePlan.RECYCLINGSTATUS_AWAITRECYCLE);
+        invoicePlanManager.terminateInvoicePlan(recyclingApplication, "oruser1", "测试中断");
+        //断言终止的结果
+        this.assertCancelTousseRecyclingApplication(recyclingApplication);
+    }
+
+
+    /**
+     * 创建器械包申请单
+     *
+     * @return {@link RecyclingApplication}
+     */
+    private RecyclingApplication createTousseRecyclingApplication() {
+        Collection<TousseItemVo> applyItemVos = new ArrayList<>();
+        appendToCollection(applyItemVos, "探针", 2, "器械包", "是", 0);
+        appendToCollection(applyItemVos, "方盒", 7, "器械包", "是", 0);
+        appendToCollection(applyItemVos, "手外科仪", 4, "器械包", "是", 0);
+        RecyclingApplication tousseApplication = ApplicationDataProvider.createApplicationByParam(InvoicePlan.TYPE_TOUSSE_APPLICATION_FORM);
+        //新建一张器械包申请单
+        recyclingApplicationManager.saveRecyclingApplication(tousseApplication, applyItemVos, true);
+        return tousseApplication;
+    }
+
+    /**
+     * 断言器械包申请单
+     *
+     * @param recyclingApplication       创建好的申请单对应的申请单
+     * @param itemAmount                 申请单下物品的数量
+     * @param recyclingApplicationStatus 申请单的状态
+     */
+    private RecyclingApplication assertTousseRecyclingApplication(RecyclingApplication recyclingApplication, int itemAmount, String recyclingApplicationStatus) {
+        HibernateTemplate ht = objectDao.getHt();
+        RecyclingApplication result = ht.get(RecyclingApplication.class, recyclingApplication.getId());
+        assertNotNull(result);
+        List<TousseItem> itemList = result.getApplicationItems();
+        assertNotNull(itemList);
+        //断言申请的物品数量
+        assertEquals(itemAmount, itemList.size());
+        //断言申请单的状态
+        assertEquals(recyclingApplicationStatus, result.getRecyclingStatus());
+        return result;
+    }
+
+    /**
+     * 断言终止的结果
+     *
+     * @param recyclingApplication 要断言的申请单
+     */
+    private RecyclingApplication assertCancelTousseRecyclingApplication(RecyclingApplication recyclingApplication) {
+        HibernateTemplate ht = objectDao.getHt();
+        RecyclingApplication result = ht.get(RecyclingApplication.class, recyclingApplication.getId());
+        assertCancelTousseRecyclingApplicationResult(result);
+        return result;
+    }
+
+    public static RecyclingApplication assertCancelTousseRecyclingApplicationResult(RecyclingApplication result) {
+        assertNotNull(result);
+        assertEquals(result.getRecyclingStatus(), InvoicePlan.STATUS_END);
+        assertEquals(result.getEndStatus(), InvoicePlan.STATUS_END);
+        assertEquals(result.getDeliverStatus(), InvoicePlan.STATUS_END);
+        assertEquals(result.getReturnStatus(), InvoicePlan.STATUS_END);
+        return result;
+    }
+
+}
Index: ssts-web/src/test/java/test/forgon/disinfectsystem/borrow/BorrowApplicationTest.java
===================================================================
diff -u -r17081 -r17530
--- ssts-web/src/test/java/test/forgon/disinfectsystem/borrow/BorrowApplicationTest.java	(.../BorrowApplicationTest.java)	(revision 17081)
+++ ssts-web/src/test/java/test/forgon/disinfectsystem/borrow/BorrowApplicationTest.java	(.../BorrowApplicationTest.java)	(revision 17530)
@@ -1,5 +1,6 @@
 package test.forgon.disinfectsystem.borrow;
 
+import com.forgon.directory.acegi.tools.AcegiHelper;
 import com.forgon.disinfectsystem.entity.basedatamanager.supplyroomconfig.SupplyRoomConfig;
 import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseDefinition;
 import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseInstance;
@@ -8,9 +9,12 @@
 import com.forgon.disinfectsystem.entity.recyclingapplication.RecyclingApplication;
 import com.forgon.disinfectsystem.entity.tousseitem.TousseItem;
 import com.forgon.disinfectsystem.entity.useRecord.UseRecord;
+import com.forgon.disinfectsystem.recyclingapplication.vo.ReturnGoodVo;
 import com.forgon.disinfectsystem.useRecord.service.UseRecordManager;
+import com.forgon.disinfectsystem.vo.TousseItemVo;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.hibernate.Session;
 import org.springframework.orm.hibernate4.HibernateTemplate;
@@ -24,6 +28,7 @@
 
 import javax.annotation.Resource;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -56,7 +61,7 @@
      * @param tousseApplication 申请单
      * @param returnAmount      归还数量
      */
-    @Test(dataProvider = "borrowProvider", dataProviderClass = BorrowAppDataProvider.class, testName = "借一张")
+    @Test(dataProvider = "borrowProvider", dataProviderClass = BorrowAppDataProvider.class)
     public void testBorrow(RecyclingApplication tousseApplication, final int returnAmount) {
         this.init();
         BorrowBo borrowBo = this.handleInvoice(tousseApplication);
@@ -194,11 +199,171 @@
         assertNotNull(recyclingApplicationById);
         assertEquals(recyclingApplicationById.getReturnStatus(), InvoicePlan.RETURN_STATUS_RETURNED);
         assertEquals(recyclingApplicationById.getOrderByFiled(), InvoicePlan.RETURN_RETURNED);
+    }
 
+
+    /**
+     * <h1>测试通过申请单来归还物品,借物单物品(Test开胸包 x2)场景如下:</h1>
+     * <dl>
+     * <dt>1. 器械包申请单申请Test开胸包 x1个来归还,比借物单物品的数量少,期待结果如下:</dt>
+     * <dd>1.1 申请的全部物品转换为还物单</dd>
+     * <dd>1.2 器械包申请单的状态是已终止</dd>
+     * <dd>1.3 器械包申请单物品数量是Test开胸包 x1</dd>
+     * <dd>1.4 申请还物单的物品数量和申请数量一样</dd>
+     * </dl>
+     * <dl>
+     * <dt>2. 器械包申请单申请Test开胸包 x2个来归还,和借物单物品的数量一样,期待结果如下:</dt>
+     * <dd>2.1 申请的全部物品转换为还物单</dd>
+     * <dd>2.2 器械包申请单的状态是已终止</dd>
+     * <dd>2.3 器械包申请单物品数量是Test开胸包 x2</dd>
+     * <dd>2.4 申请还物单的物品数量和申请数量一样</dd>
+     * </dl>
+     * <dl>
+     * <dt>3. 器械包申请单申请Test开胸包 x3个来归还,比借物单物品的数量多,期待结果如下:</dt>
+     * <dd>3.1 申请还物单的物品数量和借物单数量一样,即申请还物单的物品为Test开胸包 x2</dd>
+     * <dd>3.2 器械包申请单的物品数量 = 申请的数量 - 借物单的数量，即器械包申请的的物品为Test开胸包 x1</dd>
+     * </dl>
+     *
+     * @param borrowApplication 借物单
+     * @param applyGoodMap      器械包申请单的申请物品
+     */
+    @Test(dataProvider = "returnByApplicationProvider", dataProviderClass = BorrowAppDataProvider.class)
+    public void testReturnByApplication(RecyclingApplication borrowApplication, Map<String, Integer> applyGoodMap) {
+        this.init();
+        HibernateTemplate ht = objectDao.getHt();
+        borrowApplication.setReturnStatus(InvoicePlan.RETURN_STATUS_UNRETURNED);
+        //填写借物单和发货完毕
+        this.handleInvoice(borrowApplication);
+        //构造一张申请单
+        RecyclingApplication recyclingApplication = ApplicationDataProvider.createApplicationByParam(InvoicePlan.TYPE_TOUSSE_APPLICATION_FORM);
+        Collection<TousseItemVo> applyItemVos = this.convertApplyGoodMapToTousseItemVo(applyGoodMap);
+        //这里设置一个临时map,用于保存申请的物品
+        Map<String, Integer> tempApplyGoodMap = new HashMap<>(applyGoodMap);
+        //用申请单的物品来归还借物单的物品
+        ReturnGoodVo returnGoodVo = recyclingApplicationManager.handleReturnGoodByApplication(applyGoodMap, recyclingApplication);
+        Map<String, Integer> restApplyTousses = returnGoodVo.getRestApplyTousses();
+        //此次申请的物品列表
+        if (recyclingApplicationManager.isAllReturn(restApplyTousses)) {
+            // 若全部物品转换为还物单，则保存原申请单的状态为已终止
+            recyclingApplicationManager.saveRecyclingApplication(recyclingApplication, applyItemVos, true);
+            String userName = AcegiHelper.getLoginUser().getUserFullName();
+            String remark = "本次申请的所有物品已转换为申请还物单。";
+            invoicePlanManager.terminateInvoicePlan(recyclingApplication, userName, remark);
+            objectDao.save(recyclingApplication);
+            ht.flush();
+            this.assertAfterReturnByAllReturn(recyclingApplication, tempApplyGoodMap);
+        }
+        else {
+            // 若还有剩余物品，则以剩余的物品提交申请单
+            final Map<String, Integer> restApplyTousses2 = restApplyTousses;
+            Collection<TousseItemVo> restApplyResult = CollectionUtils.select(applyItemVos, vo -> {
+                Integer restApplyAmount = restApplyTousses2.get(vo.getTousseName());
+                if (restApplyAmount == null) {
+                    return false;
+                }
+                // 转换为还物单后，原有申请数量应修改
+                vo.setAmount(restApplyAmount);
+                return true;
+            });
+            recyclingApplicationManager.saveRecyclingApplication(recyclingApplication, restApplyResult, true);
+            this.assertAfterReturnByNotAllReturn(tempApplyGoodMap, borrowApplication);
+        }
     }
 
 
     /**
+     * 断言全部物品转换为还物单的情况,申请还物单的物品数量和申请数量一样,器械包申请单的物品数量和申请数量一样,状态是已终止
+     *
+     * @param recyclingApplication 物品的申请单
+     * @param applyGoodMap         申请的物品
+     */
+    private void assertAfterReturnByAllReturn(RecyclingApplication recyclingApplication, Map<String, Integer> applyGoodMap) {
+        HibernateTemplate ht = objectDao.getHt();
+        //断言申请的状态为已终止
+        assertEquals(recyclingApplication.getEndStatus(), InvoicePlan.STATUS_END);
+        assertEquals(recyclingApplication.getReturnStatus(), InvoicePlan.STATUS_END);
+        List<InvoicePlan> InvoicePlans = (List<InvoicePlan>) ht.find("from InvoicePlan ");
+        //断言生成了三张申请单(原来的借物单,申请还物单,终止了的申请单)
+        assertEquals(InvoicePlans.size(), 3);
+        for (InvoicePlan invoicePlan : InvoicePlans) {
+            String type = invoicePlan.getType();
+            //如果是申请还物单或者器械包申请单
+            if (InvoicePlan.TYPE_APPLYING_FOR_RETURN_FORM.equals(type) || InvoicePlan.TYPE_TOUSSE_APPLICATION_FORM.equals(type)) {
+                this.assertApplicationItems(invoicePlan, applyGoodMap);
+            }
+        }
+    }
+
+    /**
+     * 断言若还有剩余物品，则以剩余的物品提交申请单的情况,申请还物单的物品数量和借物单数量一样,器械包申请单的物品数量 = 申请的数量 - 借物单的数量
+     *
+     * @param applyGoodMap      申请的物品
+     * @param borrowApplication 借物单
+     */
+    private void assertAfterReturnByNotAllReturn(Map<String, Integer> applyGoodMap, RecyclingApplication borrowApplication) {
+        HibernateTemplate ht = objectDao.getHt();
+        List<InvoicePlan> InvoicePlans = (List<InvoicePlan>) ht.find("from InvoicePlan ");
+        //断言生成了三张申请单(原来的借物单,申请还物单,终止了的申请单)
+        assertEquals(InvoicePlans.size(), 3);
+        for (InvoicePlan invoicePlan : InvoicePlans) {
+            String type = invoicePlan.getType();
+            List<TousseItem> applicationItems = invoicePlan.getApplicationItems();
+            List<TousseItem> borrwoApplicationItems = borrowApplication.getApplicationItems();
+            //断言借物单的申请物品是1
+            assertEquals(borrwoApplicationItems.size(), 1);
+            //借物单的物品数量
+            Integer borrowAmount = borrwoApplicationItems.get(0).getAmount();
+            if (InvoicePlan.TYPE_APPLYING_FOR_RETURN_FORM.equals(type)) {
+                //如果是申请还物单，物品的数量要等于借物的数量
+                for (TousseItem applicationItem : applicationItems) {
+                    if (applicationItem.getTousseName().equals(borrwoApplicationItems.get(0).getTousseName())) {
+                        assertEquals(applicationItem.getAmount(), borrowAmount);
+                    }
+                }
+            }
+            else if (InvoicePlan.TYPE_TOUSSE_APPLICATION_FORM.equals(type)) {
+                //如果是器械包申请单，物品的数量 = 申请的数量 - 借物单的数量
+                for (TousseItem applicationItem : applicationItems) {
+                    Integer applyAmount = applyGoodMap.get(applicationItem.getTousseName());
+                    if (applicationItem.getTousseName().equals(borrwoApplicationItems.get(0).getTousseName())) {
+                        assertEquals(applicationItem.getAmount().intValue(), applyAmount - borrowAmount);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 断言申请单上的物品
+     *
+     * @param invoicePlan  物品的申请单
+     * @param applyGoodMap 申请的物品
+     */
+    private void assertApplicationItems(InvoicePlan invoicePlan, Map<String, Integer> applyGoodMap) {
+        List<TousseItem> applicationItems = invoicePlan.getApplicationItems();
+        for (TousseItem applicationItem : applicationItems) {
+            //断言里面是Test开胸包
+            assertEquals(TousseDefinitionDataProvider.Test开胸包, applicationItem.getTousseName());
+            //断言Test开胸包是申请的数量
+            assertEquals(applyGoodMap.get(TousseDefinitionDataProvider.Test开胸包).intValue(), applicationItem.getAmount().intValue());
+        }
+    }
+
+    /**
+     * 根据传进来的申请物品map转成TousseItemVo集合
+     *
+     * @param applyGoodMap 要申请的物品map
+     */
+    private Collection<TousseItemVo> convertApplyGoodMapToTousseItemVo(Map<String, Integer> applyGoodMap) {
+        Collection<TousseItemVo> applyItemVos = new ArrayList<>();
+        for (Map.Entry<String, Integer> entry : applyGoodMap.entrySet()) {
+            appendToCollection(applyItemVos, entry.getKey(), entry.getValue(), "器械包", "是", 0);
+        }
+        return applyItemVos;
+    }
+
+
+    /**
      * 使用记录转换成申请单
      *
      * @param useRecord      相关的使用记录
@@ -214,13 +379,13 @@
     }
 
     /**
-     * 准备录使用记录的参数
+     * 处理发货
      *
      * @param tousseApplication 借物单
      * @return {@link BorrowBo}
      */
     private BorrowBo handleInvoice(RecyclingApplication tousseApplication) {
-        TousseDefinition td = tousseDefinitionManager.getTousseDefinitionByName("Test开胸包");
+        TousseDefinition td = tousseDefinitionManager.getTousseDefinitionByName(TousseDefinitionDataProvider.Test开胸包);
         String[] barcodeArray = {"020000100", "020000200"};
         return this.doInvoice(tousseApplication, td, barcodeArray);
     }