HIA24016N_PipeLineDemo.git

			@@ -1,4 +1,4 @@
			using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterial;
			ï»¿using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterial;
			using CMS.Plugin.HIAWms.Application.Contracts.Services;
			using CMS.Plugin.HIAWms.Domain.Shared;
			using CMS.Plugin.HIAWms.Domain.Shared.Util;
			@@ -15,33 +15,33 @@
			namespace CMS.Plugin.HIAWms.Application.Implements;

			/// <summary>
			/// ç©æåºç¡ä¿¡æ¯åºç¨æå¡
			/// ç©æåºç¡ä¿¡æ¯è¡¨åºç¨æå¡
			/// </summary>
			public class WmsMaterialAppService : CMSPluginAppService, IWmsMaterialAppService
			{
			private readonly IWmsMaterialRepository _wmsmaterialRepository;
			private readonly IWmsMaterialRepository wmsmaterialsRepository;

			/// <summary>
			/// Initializes a new instance of the <see cref="WmsMaterialAppService"/> class.
			/// </summary>
			/// <param name="wmsmaterialRepository">The task job repository.</param>
			public WmsMaterialAppService(IWmsMaterialRepository wmsmaterialRepository)
			/// <param name="WmsMaterialRepository">The task job repository.</param>
			public WmsMaterialAppService(IWmsMaterialRepository WmsMaterialRepository)
			{
			_wmsmaterialRepository = wmsmaterialRepository;
			wmsmaterialsRepository = WmsMaterialRepository;
			}

			/// <summary>
			/// è·åæå®ç©æåºç¡ä¿¡æ¯
			/// è·åæå®ç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public virtual async Task<WmsMaterialDto> GetAsync(Guid id)
			{
			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(await _wmsmaterialRepository.GetAsync(id));
			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(await wmsmaterialsRepository.GetAsync(id));
			}

			/// <summary>
			/// åé¡µè·åç©æåºç¡ä¿¡æ¯
			/// åé¡µè·åç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			@@ -61,8 +61,8 @@

			#endregion

			var count = await _wmsmaterialRepository.GetCountAsync(whereConditions);
			var list = await _wmsmaterialRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);
			var count = await wmsmaterialsRepository.GetCountAsync(whereConditions);
			var list = await wmsmaterialsRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);

			return new PagedResultDto<WmsMaterialDto>(count, ObjectMapper.Map<List<WmsMaterial>, List<WmsMaterialDto>>(list));
			}
			@@ -91,7 +91,7 @@
			}

			/// <summary>
			/// æ°å»ºç©æåºç¡ä¿¡æ¯
			/// æ°å»ºç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			@@ -100,31 +100,31 @@
			{
			await CheckCreateOrUpdateDtoAsync(input);

			var exist = await _wmsmaterialRepository.NameExistAsync(input.MaterialCode);
			var exist = await wmsmaterialsRepository.NameExistAsync(input.MaterialCode);
			if (exist)
			{
			throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialCode]);
			}

			var maxSort = await _wmsmaterialRepository.GetMaxSortAsync();
			var maxSort = await wmsmaterialsRepository.GetMaxSortAsync();
			var sort = input.Sort ?? maxSort;

			var wmsmaterial = ObjectMapper.Map<WmsMaterialCreateDto, WmsMaterial>(input);
			wmsmaterial.Sort = sort;
			input.MapExtraPropertiesTo(wmsmaterial, MappingPropertyDefinitionChecks.None);
			var insertObj = ObjectMapper.Map<WmsMaterialCreateDto, WmsMaterial>(input);
			insertObj.Sort = sort;
			input.MapExtraPropertiesTo(insertObj, MappingPropertyDefinitionChecks.None);

			await _wmsmaterialRepository.InsertAsync(wmsmaterial);
			await wmsmaterialsRepository.InsertAsync(insertObj);

			if (input.Sort.HasValue && wmsmaterial.Sort != maxSort)
			if (input.Sort.HasValue && insertObj.Sort != maxSort)
			{
			await AdjustSortAsync(wmsmaterial.Id, wmsmaterial.Sort);
			await AdjustSortAsync(insertObj.Id, insertObj.Sort);
			}

			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(wmsmaterial);
			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(insertObj);
			}

			/// <summary>
			/// æ´æ°ç©æåºç¡ä¿¡æ¯
			/// æ´æ°ç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="id"></param>
			/// <param name="input"></param>
			@@ -134,56 +134,63 @@
			{
			await CheckCreateOrUpdateDtoAsync(input);

			var wmsmaterial = await _wmsmaterialRepository.GetAsync(id);
			var exist = await _wmsmaterialRepository.NameExistAsync(input.MaterialCode, wmsmaterial.Id);
			var updateObj = await wmsmaterialsRepository.GetAsync(id);
			var exist = await wmsmaterialsRepository.NameExistAsync(input.MaterialCode, updateObj.Id);
			if (exist)
			{
			throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialCode]);
			}

			wmsmaterial.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
			input.MapExtraPropertiesTo(wmsmaterial, MappingPropertyDefinitionChecks.None);
			updateObj.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
			input.MapExtraPropertiesTo(updateObj, MappingPropertyDefinitionChecks.None);

			wmsmaterial.MaterialName = input.MaterialName;
			wmsmaterial.PurchaseType = input.PurchaseType;
			wmsmaterial.MaterialType = input.MaterialType;
			wmsmaterial.PrimaryUnit = input.PrimaryUnit;
			wmsmaterial.Standard = input.Standard;
			wmsmaterial.OuterDiameter = input.OuterDiameter;
			wmsmaterial.WallThickness = input.WallThickness;
			wmsmaterial.MaterialQuality = input.MaterialQuality;
			wmsmaterial.Length = input.Length;
			wmsmaterial.IsMainBranch = input.IsMainBranch;
			wmsmaterial.Factory = input.Factory;
			wmsmaterial.Certification = input.Certification;
			updateObj.MaterialCode = input.MaterialCode;
			updateObj.MaterialName = input.MaterialName;
			updateObj.PurchaseType = input.PurchaseType;
			updateObj.MaterialType = input.MaterialType;
			updateObj.PrimaryUnit = input.PrimaryUnit;
			updateObj.Standard = input.Standard;
			updateObj.OuterDiameter = input.OuterDiameter;
			updateObj.WallThickness = input.WallThickness;
			updateObj.MaterialQuality = input.MaterialQuality;
			updateObj.Length = input.Length;
			updateObj.IsMainBranch = input.IsMainBranch;
			updateObj.Factory = input.Factory;
			updateObj.Certification = input.Certification;
			updateObj.RedundantField1 = input.RedundantField1;
			updateObj.RedundantField2 = input.RedundantField2;
			updateObj.RedundantField3 = input.RedundantField3;
			updateObj.Remark = input.Remark;
			updateObj.IsDisabled = input.IsDisabled;

			await _wmsmaterialRepository.UpdateAsync(wmsmaterial);

			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(wmsmaterial);
			await wmsmaterialsRepository.UpdateAsync(updateObj);

			return ObjectMapper.Map<WmsMaterial, WmsMaterialDto>(updateObj);
			}

			/// <summary>
			/// åéç©æåºç¡ä¿¡æ¯
			/// åéç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="ids"></param>
			/// <returns></returns>
			public async Task<List<WmsMaterialDto>> CloneAsync(IEnumerable<Guid> ids)
			{
			//var wmsmaterials = new List<WmsMaterial>();
			//var wmsmaterialss = new List<WmsMaterial>();
			//if (ids != null)
			//{
			// var sort = await _wmsmaterialRepository.GetMaxSortAsync();
			// var sort = await wmsmaterialsRepository.GetMaxSortAsync();
			// foreach (var id in ids)
			// {
			// var wmsmaterial = await _wmsmaterialRepository.FindAsync(id);
			// if (wmsmaterial != null)
			// var WmsMaterial = await wmsmaterialsRepository.FindAsync(id);
			// if (WmsMaterial != null)
			// {
			// var name = wmsmaterial.Name + WmsMaterialConsts.CloneTag;
			// var name = WmsMaterial.Name + WmsMaterialConsts.CloneTag;
			// var notExist = false;
			// while (!notExist)
			// {
			// var exist = await _wmsmaterialRepository.NameExistAsync(name);
			// if (exist \|\| wmsmaterials.Any(x => x.Name == name))
			// var exist = await wmsmaterialsRepository.NameExistAsync(name);
			// if (exist \|\| wmsmaterialss.Any(x => x.Name == name))
			// {
			// name += WmsMaterialConsts.CloneTag;
			// continue;
			@@ -192,28 +199,28 @@
			// notExist = true;
			// }

			// //wmsmaterial = await _wmsmaterialRepository.InsertAsync(wmsmaterial.Clone(GuidGenerator.Create(), name, sort++));
			// wmsmaterials.Add(wmsmaterial);
			// //WmsMaterial = await wmsmaterialsRepository.InsertAsync(WmsMaterial.Clone(GuidGenerator.Create(), name, sort++));
			// wmsmaterialss.Add(WmsMaterial);
			// }
			// }
			//}

			//return ObjectMapper.Map<List<WmsMaterial>, List<WmsMaterialDto>>(wmsmaterials);
			//return ObjectMapper.Map<List<WmsMaterial>, List<WmsMaterialDto>>(wmsmaterialss);
			return new List<WmsMaterialDto>();
			}

			/// <summary>
			/// å é¤åä¸ªç©æåºç¡ä¿¡æ¯
			/// å é¤åä¸ªç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public virtual Task DeleteAsync(Guid id)
			{
			return _wmsmaterialRepository.DeleteAsync(id);
			return wmsmaterialsRepository.DeleteAsync(id);
			}

			/// <summary>
			/// å é¤å¤ä¸ªç©æåºç¡ä¿¡æ¯
			/// å é¤å¤ä¸ªç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="ids"></param>
			/// <returns></returns>
			@@ -226,14 +233,14 @@
			}

			/// <summary>
			/// è°æ´æåºç©æåºç¡ä¿¡æ¯
			/// è°æ´æåºç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="id"></param>
			/// <param name="sort"></param>
			/// <returns></returns>
			public virtual async Task AdjustSortAsync(Guid id, int sort)
			{
			var list = await _wmsmaterialRepository.GetListAsync(null, nameof(WmsMaterial.Sort));
			var list = await wmsmaterialsRepository.GetListAsync(null, nameof(WmsMaterial.Sort));
			if (list != null && list.Any())
			{
			var initSort = 1;
			@@ -260,11 +267,11 @@
			}
			}

			await _wmsmaterialRepository.UpdateManyAsync(list);
			await wmsmaterialsRepository.UpdateManyAsync(list);
			}

			/// <summary>
			/// å¯¼å¥ç©æåºç¡ä¿¡æ¯
			/// å¯¼å¥ç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			@@ -273,8 +280,8 @@
			{
			Check.NotNull(input, nameof(input));

			var wmsmaterialCreateDtos = new List<(int RowIndex, WmsMaterialCreateDto Item)>();
			var wmsmaterialUpdateDtos = new List<(int RowIndex, Guid Id, WmsMaterialUpdateDto Item)>();
			var wmsmaterialsCreateDtos = new List<(int RowIndex, WmsMaterialCreateDto Item)>();
			var wmsmaterialsUpdateDtos = new List<(int RowIndex, Guid Id, WmsMaterialUpdateDto Item)>();
			var importItems = input.WmsMaterials;

			if (importItems != null && importItems.Any())
			@@ -305,10 +312,10 @@
			throw new UserFriendlyException(errorMsg);
			}

			var oldWmsMaterial = await _wmsmaterialRepository.FindByNameAsync(impItem.MaterialCode);
			var oldWmsMaterial = await wmsmaterialsRepository.FindByNameAsync(impItem.MaterialCode);
			if (oldWmsMaterial != null)
			{
			var wmsmaterialUpdateDto = new WmsMaterialUpdateDto
			var wmsmaterialsUpdateDto = new WmsMaterialUpdateDto
			{
			MaterialCode = impItem.MaterialCode,
			MaterialName = impItem.MaterialName,
			@@ -326,11 +333,11 @@
			Remark = impItem.Remark,
			};

			wmsmaterialUpdateDtos.Add((impItem.RowIndex, oldWmsMaterial.Id, wmsmaterialUpdateDto));
			wmsmaterialsUpdateDtos.Add((impItem.RowIndex, oldWmsMaterial.Id, wmsmaterialsUpdateDto));
			}
			else
			{
			var wmsmaterialCreateDto = new WmsMaterialCreateDto
			var wmsmaterialsCreateDto = new WmsMaterialCreateDto
			{
			MaterialCode = impItem.MaterialCode,
			MaterialName = impItem.MaterialName,
			@@ -348,42 +355,42 @@
			Remark = impItem.Remark,
			};

			wmsmaterialCreateDtos.Add((impItem.RowIndex, wmsmaterialCreateDto));
			wmsmaterialsCreateDtos.Add((impItem.RowIndex, wmsmaterialsCreateDto));
			}
			}
			}

			// æ°å¢
			foreach (var wmsmaterialDto in wmsmaterialCreateDtos)
			foreach (var wmsmaterialsDto in wmsmaterialsCreateDtos)
			{
			try
			{
			await CreateAsync(wmsmaterialDto.Item);
			await CreateAsync(wmsmaterialsDto.Item);
			}
			catch (Exception e)
			{
			var errorMsg = $"å¯¼å¥å¤±è´¥ï¼éç½®ï¼ç¬¬{wmsmaterialDto.RowIndex}è¡ï¼{e.Message}ï¼ç»æ¢å¯¼å¥";
			var errorMsg = $"å¯¼å¥å¤±è´¥ï¼éç½®ï¼ç¬¬{wmsmaterialsDto.RowIndex}è¡ï¼{e.Message}ï¼ç»æ¢å¯¼å¥";
			throw new UserFriendlyException(errorMsg);
			}
			}

			// æ´æ°
			foreach (var wmsmaterialDto in wmsmaterialUpdateDtos)
			foreach (var wmsmaterialsDto in wmsmaterialsUpdateDtos)
			{
			try
			{
			await UpdateAsync(wmsmaterialDto.Id, wmsmaterialDto.Item);
			await UpdateAsync(wmsmaterialsDto.Id, wmsmaterialsDto.Item);
			}
			catch (Exception e)
			{
			var errorMsg = $"å¯¼å¥å¤±è´¥ï¼éç½®ï¼ç¬¬{wmsmaterialDto.RowIndex}è¡ï¼{e.Message}ï¼ç»æ¢å¯¼å¥";
			var errorMsg = $"å¯¼å¥å¤±è´¥ï¼éç½®ï¼ç¬¬{wmsmaterialsDto.RowIndex}è¡ï¼{e.Message}ï¼ç»æ¢å¯¼å¥";
			throw new UserFriendlyException(errorMsg);
			}
			}
			}

			/// <summary>
			/// å¯¼åºç©æåºç¡ä¿¡æ¯
			/// å¯¼åºç©æåºç¡ä¿¡æ¯è¡¨
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			@@ -404,7 +411,7 @@
			#endregion


			var list = await _wmsmaterialRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount, includeDetails: true);
			var list = await wmsmaterialsRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount, includeDetails: true);
			var result = ObjectMapper.Map<List<WmsMaterial>, List<WmsMaterialDto>>(list);

			var sheets = new Dictionary<string, object>
			@@ -417,16 +424,22 @@
			}

			/// <summary>
			/// æ ¡éªç©æåºç¡ä¿¡æ¯ï¼å½æ°å»ºææ´æ°æ¶
			/// æ ¡éªç©æåºç¡ä¿¡æ¯è¡¨ï¼å½æ°å»ºææ´æ°æ¶
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			protected Task CheckCreateOrUpdateDtoAsync(WmsMaterialCreateOrUpdateDtoBase input)
			{
			Check.NotNull(input, nameof(input));
			Check.NotNullOrWhiteSpace(input.MaterialCode, "ç¼å·", WmsMaterialConsts.MaxCodeLength);
			Check.NotNullOrWhiteSpace(input.MaterialName, "åç§°", WmsMaterialConsts.MaxNameLength);
			Check.Length(input.Remark, "å¤æ³¨", WmsMaterialConsts.MaxRemarkLength);
			Check.NotNullOrWhiteSpace(input.MaterialCode, "ç©æç¼ç ï¼å¯ä¸æ è¯ï¼", 64);
			Check.NotNullOrWhiteSpace(input.MaterialName, "ç©æåç§°", 128);
			Check.NotNull(input.PurchaseType, "éè´ç±»åï¼æä¸¾å¼ï¼");
			Check.NotNull(input.MaterialType, "ç©æç±»åï¼æä¸¾å¼ï¼");
			Check.NotNull(input.OuterDiameter, "å¤å¾ï¼åä½ï¼mmï¼");
			Check.NotNull(input.WallThickness, "å£åï¼åä½ï¼mmï¼");
			Check.NotNull(input.Length, "é¿åº¦ï¼åä½ï¼mï¼");
			Check.NotNull(input.IsMainBranch, "æ¯å¦ä¸ºä¸»æ¯ç®¡");

			return Task.CompletedTask;
			}
			}