Dynamics CRM中自定义页面实现附件管理包含下载模板、上传、下载、删除

  1 using Microsoft.Xrm.Sdk;
  2 using Microsoft.Xrm.Sdk.Query;
  3 using Newtonsoft.Json;
  4 using NPOI.OpenXml4Net.OPC.Internal;
  5 using System;
  6 using System.Collections.Generic;
  7 using System.Data.Entity.Core.Objects.DataClasses;
  8 using System.IO;
  9 using System.Linq;
 10 using System.Net;
 11 using System.Net.Http;
 12 using System.Net.Http.Headers;
 13 using System.Reflection;
 14 using System.Text;
 15 using System.Threading.Tasks;
 16 using System.Web;
 17 using System.Web.Http;
 18 using ZZ_Common_API.Crm;
 19 using ZZ_Common_API.Models.QDRWModels;
 20 using EntityReference = Microsoft.Xrm.Sdk.EntityReference;
 21 
 22 namespace ZZ_Common_API.Controllers.QDRWControllers
 23 {
 24     /// 

 25     /// 附件相关WebAPI接口
 26     /// 
 27     [RoutePrefix("AccountChannelAccess")]
 28     public class AccountChannelAccessController : ApiController
 29     {
 30         #region 下载模板文件 strat
 31         /// 

 32         /// 下载附件
 33         /// 
 34         /// 1商业计划书新签,2商业计划书续签,3渠道基本信息评价表,4海外网络退出要素确认表
 35         /// 
 36         [Route("DownloadFileTemplate")]
 37         [HttpGet]
 38         public async Taskdynamic> DownloadFileTemplate(int type) 
 39         {
 40             HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
 41             string fileName = string.Empty;
 42             switch (type)
 43             {
 44                 case 1:
 45                     fileName = "附件1：商业计划书新签(可下载模版).pptx";
 46                     break;
 47                 case 2:
 48                     fileName = "附件2：商业计划书续签(可下载模版).pptx";
 49                     break;
 50                 case 3:
 51                     fileName = "附件3：渠道基本信息评价表(可下载模版).docx";
 52                     break;
 53                 case 4:
 54                     fileName = "附件4：海外网络退出要素确认表（可下载模板）.docx";
 55                     break;
 56                 default:
 57                     fileName = "附件1：商业计划书新签(可下载模版).pptx";
 58                     break;
 59             }
 60            
 61             var filePath = AppDomain.CurrentDomain.BaseDirectory + @"FilesTemplate" + fileName;
 62             if (!File.Exists(filePath))
 63             {
 64                 return ResponseMessage(new HttpResponseMessage()
 65                 {
 66                     Content =
 67                      new StringContent(JsonConvert.SerializeObject(Json(new { code = 0, msg = $"下载失败，未能找到文件-{fileName}的路径" })),
 68                        Encoding.GetEncoding("UTF-8"), "application/json"),
 69                     StatusCode = HttpStatusCode.NoContent
 70                 });
 71             }
 72             var stream = new FileStream(filePath, FileMode.Open);
 73             responseMessage.Content = new StreamContent(stream);
 74             responseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
 75             HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlPathEncode(fileName));
 76             return ResponseMessage(responseMessage);
 77         }
 78         
 79 
 80         #endregion 下载模板文件 end
 81 
 82         #region 上传附件 start
 83         /// 

 84         /// 使用系统的注释Annotation  添加附件
 85         /// 
 86         /// 
 87         [Route("SaveAnnotation")]
 88         [HttpPost]
 89         public object SaveAnnotation()
 90         {
 91             try
 92             {
 93          服务器托管网       HttpFileCollection fileCollection = HttpContext.Current.Request.Files;
 94                 if (fileCollection.Count 0)
 95                 {
 96                     return Json(new { code = 0, msg = $"请先选择文件后点击上传" });
 97                 }
 98                 var formData = HttpContext.Current.Request.Form;
 99                 var entityId = formData["entityId"];
100                 var entityName = formData["entityName"];
101 
102                 Guid objId = Guid.Empty;
103                 if (!Guid.TryParse(entityId, out objId)) //检验实体id是否合法
104                 {
105                     return Json(new { code = 0, msg = $"上传失败，entityId是不合法的GUID：{entityId}" });
106                 }
107                 HttpPostedFile formFile = fileCollection[0];
108                 if (formFile.ContentLength > 1048576000)//检查文件大小
109                 {
110                     return Json(new { code = 0, msg = $"{formFile.FileName}文件大小不得超过{1048576000 / (1024f * 1024f)}M" });//请求体过大，文件大小超标
111                 }
112                 var suffix = Path.GetExtension(formFile.FileName);//提取上传的文件文件后缀
113                 if (".js;.bat;.exe;.sh".IndexOf(suffix) > 0) //检查文件格式
114                 {
115                     return Json(new { code = 0, msg = $"不支持此文件类型-{suffix}" });//类型不正确
116                 }
117 
118                 AnnotationModel model = new AnnotationModel();
119                 model.Subject = Path.GetFileName(formFile.FileName).Substring(1);
120                 model.NoteText = "";
121                 model.ObjectId = objId;
122                 model.ObjectIdName = entityName;
123                 model.MimeType = formFile.ContentType;
124                 model.FileSize = formFile.ContentLength;
125                 model.FileName = Path.GetFileName(formFile.FileName);
126                 model.DocumentBody = Convert.ToBase64String(GetFileByte(formFile));
127                 //保存到Annotation中
128                 CreateAnnotation(model);
129 
130                 return Json(new { code = 1, msg = "上传成功" });
131             }
132             catch (Exception ex)
133             {
134                 return Json(new { code = 0, msg = $"上传失败 + {ex.Message}" });
135             }
136         }
137         #endregion 上传附件 end
138 
139         #region 下载附件 start
140         /// 

141         /// 下载附件
142         /// 
143         /// 附件id
144         /// 
145         [Route("DownloadAnnotation")]
146         [AcceptVerbs("GET")]
147         public IHttpActionResult DownloadAnnotation(string id)
148         {
149             //通过附件id 找到附件 然后转化附件字节流 填入到响应中
150             HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
151             try
152             {
153                 if (string.IsNullOrEmpty(id))
154                 {
155                     return ResponseMessage(new HttpResponseMessage(HttpStatusCode.Gone));
156                 }
157                 Tuplestring, Stream> tuple = GetAnnotationStream(id);
158                 if (tuple.Item1 == "未能获取到字节流")
159                 {
160                     return ResponseMessage(new HttpResponseMessage(HttpStatusCode.Gone));
161                 }
162                 responseMessage.Content = new StreamContent(tuple.Item2);
163                 responseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
164                 HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlPathEncode(tuple.Item1));
165             }
166             catch (Exception ex)
167             {
168                 return ResponseMessage(new HttpResponseMessage()
169                 {
170                     Content =
171                      new StringContent(JsonConvert.SerializeObject(Json(new { code = 0, msg = $"下载失败-{ex.Message}" })),
172                        Encoding.GetEncoding("UTF-8"), "application/json"),
173                     StatusCode = HttpStatusCode.NoContent
174                 });
175             }
176             return ResponseMessage(responseMessage);
177         }
178         #endregion 下载附件 end
179 
180         #region 根据实体id获取实体数据下相关所有附件，打包成zip文件下载 start
181         /// 

182         /// 下载实体数据下所有的附件zip
183         /// 根据实体id获取实体数据下相关所有附件，打包成zip文件下载
184         /// 
185         /// 
186         /// 
187         [Route("DownloadAnnotationAll")]
188         [AcceptVerbs("GET")]
189         public IHttpActionResult DownloadAnnotationAll(string id)
190         {
191             HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
192             try
193             {
194                 if (string.IsNullOrEmpty(id))
195                 {
196                     return ResponseMessage(new HttpResponseMessage(HttpStatusCode.Gone));
197                 }
198                 //通过模块id 找到相关的所有附件 然后将所有的附件打包成zip文件 将zip文件转化字节流 填入到响应流中
199                 if (string.IsNullOrEmpty(id))
200                 {
201                     return ResponseMessage(new HttpResponseMessage(HttpStatusCode.Gone));
202                 }
203                 Tuplestring, Stream> tuple = GetAllAnnotationStream(id);
204                 if (tuple.Item1 == "未能获取到字节流")
205                 {
206                     return ResponseMessage(new HttpResponseMessage(HttpStatusCode.Gone));
207                 }
208                 responseMessage.Content = new StreamContent(tuple.Item2);
209                 responseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
210                 HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlPathEncode(tuple.Item1));
211             }
212             catch (Exception ex)
213             {
214                 return ResponseMessage(new HttpResponseMessage()
215                 {
216                     Content =
217                      new StringContent(JsonConvert.SerializeObject(Json(new { code = 0, msg = $"下载失败-{ex.Message}" })),
218                        Encoding.GetEncoding("UTF-8"), "application/json"),
219                     StatusCode = HttpStatusCode.NoContent
220                 });
221             }
222             return ResponseMessage(responseMessage);
223         }
224 
225         #endregion 根据实体id获取实体数据下相关所有附件，打包成zip文件下载 end
226 
227         #region API专用 删除附件
228         /// 

229         /// 删除附件
230         /// 
231         /// 附件ids
232         /// 
233         [Route("DelAnnotation")]
234         [HttpPost]
235         public object DelAnnotation([FromBody] string id)
236         {
237             try
238             {
239                 if (string.IsNullOrEmpty(id))
240                 {
241                     return Json(new { code = 0, msg = $"删除附件时id不能为空" });
242                 }
243                 DeleteAnnotation(id);
244                 return Json(new { code = 1, msg = "删除成功" }); ;
245             }
246             catch (Exception ex)
247             {
248                 return Json(new { code = 0, msg = $"删除失败：{ex.Message}" });
249             }
250         }
251         #endregion API专用 删除附件
252 
253         #region 内部方法 start
254 
255         #region 上传附件存到Annotation中 start
256         /// 

257         /// 将上传文件对象转化成byte字节流
258         /// 
259         /// 上传文件
260         /// 
261         private byte[] GetFileByte(HttpPostedFile httpPostedFile)
262         {
263             byte[] bytes = new byte[httpPostedFile.ContentLength];
264             using (BinaryReader reader = new BinaryReader(httpPostedFile.InputStream, Encoding.UTF8))
265             {
266                 bytes = reader.ReadBytes(bytes.Length);
267             }
268             return bytes;
269         }
270         /// 

271         /// 创建附件数据
272         /// 
273         /// 
274         /// 
275         private Guid CreateAnnotation(AnnotationModel annotation)
276         {
277             Guid guid = Guid.Empty;
278             IOrganizationService orgService = OrgServiceUtil.Client;
279             Entity entity = new Entity("annotation");
280             entity["filename"] = annotation.FileName;
281             entity["subject"] = annotation.Subject;
282             entity["mimetype"] = annotation.MimeType;
283             entity["filesize"] = annotation.FileSize;
284             entity["documentbody"] = annotation.DocumentBody;
285             entity["objectid"] = new EntityReference(annotation.ObjectIdName, annotation.ObjectId);
286             guid = orgService.Create(entity);
287             return guid;
288         }
289         #endregion 上传附件存到Annotation中 end
290 
291 
292         #region 根据附件id获取附件字节流 start
293         /// 

294         /// 根据附件id获取附件字节流
295         /// 
296         /// annotationid
297         /// 
298         public Tuplestring, Stream> GetAnnotationStream(string annotationid)
299         {
300             Tuplestring, Stream> rr = new Tuplestring, Stream>("未能获取到字节流", null);
301             try
302             {
303                 IOrganizationService orgService = OrgServiceUtil.Client;
304                 ColumnSet cols = new ColumnSet("filename", "documentbody");
305                 Entity entity = orgService.Retrieve("annotation", new Guid(annotationid), cols);
306                 string documentbody = entity.GetAttributeValuestring>("documentbody");
307                 string filename = entity.GetAttributeValuestring>("filename");
308                 byte[] fileContent = Convert.FromBase64String(documentbody);
309                 Stream fileStream = new MemoryStream(fileContent);
310                 rr = new Tuplestring, Stream>(filename, fileStream);
311             }
312             catch (Exception)
313             {
314                 return rr;
315             }
316             return rr;
317         }
318         #endregion 根据附件id获取附件字节流 end
319 
320         #region 根据实体数据id获取所有附件并打包成zip文件，然后转换成字节流 start
321         /// 

322         /// 根据实体数据id获取所有附件达成zip包后转换成字节流
323         /// 
324         /// 实体数据id
325         /// 
326         public Tuplestring, Stream> GetAllAnnotationStream(string entityId)
327         {
328             Tuplestring, Stream> rr = new Tuplestring, Stream>("未能获取到字节流", null);
329             try
330             {
331                 IOrganizationService orgService = OrgServiceUtil.Client;
332                 //1.根据实体数据id查询出所有相关得附件
333                 var dbList = GetDbFileByEntityId(orgService,new Guid(entityId));
334                 //2.遍历所有相关得附件 将各个附件流转化存放到内存字典中
335                 Dictionarystring, byte[]> dic = new Dictionarystring, byte[]>();
336                 foreach (var cc in dbList)
337                 {
338                     string documentbody = cc.GetAttributeValuestring>("documentbody");
339                     string filename = cc.GetAttributeValuestring>("filename");
340                     byte[] fileContent = Convert.FromBase64String(documentbody);
341                     Tuplestring, byte[]> tt = new Tuplestring, byte[]>(filename, fileContent);
342                     if (tt.Item2 == null)
343                     {
344                         continue;
345                     }
346                     dic.Add(tt.Item1, tt.Item2);
347                 }
348                 if (dic.Count > 0)
349                 {
350                     //3.将多个字节流从字典压缩成zip文件并转成一个字节流
351                     Stream stream = ZipByteHelper.SetbytesToZipStream2(dic);
352                     rr = new Tuplestring, Stream>("附件.zip", stream);
353                 }
354             }
355             catch (Exception)
356             {
357                 return rr;
358             }
359             return rr;
360         }
361 
362         private List GetDbFileByEntityId(IOrganizationService orgService,Guid entityId) 
363         {
364             var list = new List();
365             QueryExpression query = new QueryExpression("annotation");
366             query.ColumnSet = new ColumnSet(true);
367             query.Criteria.AddCondition(new ConditionExpression("objectid", ConditionOperator.Equal, entityId));
368             var datas = orgService.RetrieveMultiple(query);
369             list = datas.Entities.ToArray().ToList();
370             return list;
371         }
372         #endregion 根据实体数据id获取所有附件并打包成zip文件，然后转化称字节流 end
373 
374         #region 删除附件 start
375         /// 

376         /// 删除附件注释
377         /// 
378         /// 附件id
379         /// 
380         /// 
381         public bool DeleteAnnotation(string annotationid)
382         {
383             bool result = true;
384             if (string.IsNullOrEmpty(annotationid))
385             {
386                 result = false;
387             }
388             IOrganizationService orgService = OrgServiceUtil.Client;
389             orgService.Delete("annotation", Guid.Parse(annotationid));
390             return result;
391         }
392         #endregion 删除附件 end
393         #endregion 内部方法 end
394     }
395 }