// POST api/<controller> public async Task <IHttpActionResult> Post([FromBody] SaveAttachmentRequest request) { if (Request.Headers.Contains("Authorization")) { // Request contains bearer token, validate it var scopeClaim = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/scope"); if (scopeClaim != null) { // Check the allowed scopes string[] addinScopes = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/scope").Value.Split(' '); if (!addinScopes.Contains("access_as_user")) { return(BadRequest("The bearer token is missing the required scope.")); } } else { return(BadRequest("The bearer token is invalid.")); } // Passed validation, process the request return(await SaveAttachmentsWithSsoToken(request)); } else { // No bearer token, so this is a request without SSO // Access tokens are included in the request return(await SaveAttachmentsWithDistinctTokens(request)); } }
/// <summary> /// Saves the attachment. /// </summary> /// <param name="filesViewModel">The files view model.</param> /// <param name="page">The page.</param> /// <param name="StorageSource">The storage source.</param> /// <param name="ContactID">The contact identifier.</param> /// <param name="OpportunityID">The opportunity identifier.</param> /// <returns></returns> public JsonResult SaveAttachment(FilesViewModel[] filesViewModel, string page, char StorageSource, int?ContactID, int?OpportunityID) { SaveAttachmentRequest request = new SaveAttachmentRequest() { ContactId = ContactID, OpportunityID = OpportunityID, CreatedBy = this.Identity.ToUserID(), filesViewModel = filesViewModel, StorageSource = StorageSource }; return(Json(new { success = attachmentService.SaveAttachment(request), response = "", responseUrl = "" }, JsonRequestBehavior.AllowGet)); }
public virtual SubmitResult SaveAttachment(SaveAttachmentRequest req) { req.AttachmentTypeId = req.AttachmentTypeId == 0 ? DefaultAttachmentType : req.AttachmentTypeId; var cat = unit.AttachmentCategoryRepository.FindSingle(req.AttachmentTypeId); var path = Path.Combine(_paths.TempFolder, req.TmpPath); var dto = new FileBytes(path); if (dto.Bytes == null) { return(new SubmitResult(1, "MSG_file_is_not_in_tmp")); } ValidateFiles(cat, new[] { dto }); var att = new Attachment() { FileName = req.Name, AttachmentCategoryId = req.AttachmentTypeId }; string url = null; if (req.SaveInDb) { att.BinaryAttachment = new BinaryAttachment(dto.Bytes); } else { var root = _paths.RootFolderPath; var name = Guid.NewGuid(); url = Utils.CombineUrl(cat.FolderPath ?? "default", name.ToString() + dto.Extension); att.FullPath = Path.Combine(root, url).Replace("/", "\\"); Utils.CreateFolderForFile(att.FullPath); File.WriteAllBytes(att.FullPath, dto.Bytes); } unit.AttachmentRepository.Add(att); var s = unit.SaveChanges(); s.Data["FileData"] = new SavedFileDto { Id = att.Id.ToString(), Path = url }; return(s); }
// POST api/<controller> public async Task <IHttpActionResult> Post([FromBody] SaveAttachmentRequest request) { if (Request.Headers.Contains("Authorization")) { // Request contains bearer token, validate it var scopeClaim = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/scope"); if (scopeClaim != null) { // Check the allowed scopes string[] addinScopes = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/scope").Value.Split(' '); if (!addinScopes.Contains("access_as_user")) { return(BadRequest("The bearer token is missing the required scope.")); } } else { return(BadRequest("The bearer token is invalid.")); } var issuerClaim = ClaimsPrincipal.Current.FindFirst("iss"); var tenantIdClaim = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid"); if (issuerClaim != null && tenantIdClaim != null) { // validate the issuer string expectedIssuer = string.Format("https://login.microsoftonline.com/{0}/v2.0", tenantIdClaim.Value); if (string.Compare(issuerClaim.Value, expectedIssuer, StringComparison.OrdinalIgnoreCase) != 0) { return(BadRequest("The token issuer is invalid.")); } } else { return(BadRequest("The bearer token is invalid.")); } // Passed validation, process the request return(await SaveAttachmentsWithSsoToken(request)); } else { // No bearer token, so this is a request without SSO // Access tokens are included in the request return(await SaveAttachmentsWithDistinctTokens(request)); } }
public bool SaveAttachment(SaveAttachmentRequest request) { foreach (var file in request.filesViewModel) { string storageFileName = System.Guid.NewGuid().ToString(); int FileTypeID; string Extension = Path.GetExtension(file.Name); if (!string.IsNullOrEmpty(Extension)) { if (Extension.ToLower() == ".jpg" || Extension.ToLower() == ".jpeg" || Extension.ToLower() == ".png" || Extension.ToLower() == ".bmp") { FileTypeID = (int)FileType.image; } else if (Extension.ToLower() == ".doc" || Extension.ToLower() == ".docx") { FileTypeID = (int)FileType.word; } else if (Extension.ToLower() == ".xls" || Extension.ToLower() == ".xlsx") { FileTypeID = (int)FileType.excel; } else if (Extension.ToLower() == ".txt") { FileTypeID = (int)FileType.txt; } else if (Extension.ToLower() == ".pdf") { FileTypeID = (int)FileType.pdf; } else if (Extension.ToLower() == ".csv") { FileTypeID = (int)FileType.csv; } else if (Extension.ToLower() == ".rtf") { FileTypeID = (int)FileType.rtf; } else { FileTypeID = (int)FileType.others; } } else { FileTypeID = (int)FileType.others; } AttachmentViewModel viewModel = new AttachmentViewModel() { ContactID = request.ContactId, DocumentTypeID = (int)DocumentType.General, FileTypeID = FileTypeID, CreatedBy = request.CreatedBy, CreatedDate = DateTime.Now.ToUniversalTime(), FilePath = file.Link, OriginalFileName = file.Name, StorageFileName = storageFileName, OpportunityID = request.OpportunityID, StorageSource = request.StorageSource }; Attachment attachment = Mapper.Map <AttachmentViewModel, Attachment>(viewModel); attachmentRepository.Insert(attachment); unitOfWork.Commit(); } return(true); }
public virtual SubmitResult SaveAttachment([FromBody] SaveAttachmentRequest req) => service.SaveAttachment(req);
public async Task <string> SaveAttachmentOneDrive([FromBody] SaveAttachmentRequest request) { if (request == null || !request.IsValid() || request.attachmentIds.Length == 0) { return(null); } string attachmentsUrl = null; using (var client = new HttpClient()) { // Get content bytes string baseAttachmentUri = request.outlookRestUrl; if (!baseAttachmentUri.EndsWith("/")) { baseAttachmentUri += "/"; } baseAttachmentUri += "v2.0/me/messages/" + request.messageId + "/attachments/"; var i = 0; foreach (string attachmentId in request.attachmentIds) { var getAttachmentReq = new HttpRequestMessage(HttpMethod.Get, baseAttachmentUri + attachmentId); // Headers getAttachmentReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", request.outlookToken); getAttachmentReq.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var result = await client.SendAsync(getAttachmentReq); string json = await result.Content.ReadAsStringAsync(); OutlookAttachment attachment = JsonConvert.DeserializeObject <OutlookAttachment>(json); // For files, build a stream directly from ContentBytes if (attachment.Size < (4 * 1024 * 1024)) { MemoryStream fileStream = new MemoryStream(Convert.FromBase64String(attachment.ContentBytes)); // Get access token from SQL database var token = Data.GetUserSessionToken(Settings.GetUserAuthStateId(ControllerContext.HttpContext), Settings.AzureADAuthority); // TODO: Check if the file already exists attachmentsUrl = await GraphApiHelper.saveAttachmentOneDrive(token.AccessToken, Format.MakeFileNameValid(request.filenames[i]), fileStream, Format.MakeFileNameValid(request.subject)); // Format string delete = "/" + request.filenames[i]; attachmentsUrl = attachmentsUrl.Replace(delete, ""); i++; } else { // Functionality to support > 4 MB files // See https://docs.microsoft.com/en-us/graph/api/driveitem-createuploadsession?view=graph-rest-1.0 var token = Data.GetUserSessionToken(Settings.GetUserAuthStateId(ControllerContext.HttpContext), Settings.AzureADAuthority); DriveItem folder = await GraphApiHelper.searchFileOneDrive(token.AccessToken, "Outlook Attachments"); var url = "https://graph.microsoft.com/v1.0" + $"/me/drive/items/{folder.Id}:/{attachment.Name}:/createUploadSession"; var uploadReq = new HttpRequestMessage(HttpMethod.Post, url); // Headers uploadReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); // Send request var sessionResponse = client.SendAsync(uploadReq).Result.Content.ReadAsStringAsync().Result; var uploadSession = JsonConvert.DeserializeObject <UploadSessionResponse>(sessionResponse); Upload upload = new Upload(); HttpResponseMessage response = upload.UploadFileBySession(uploadSession.uploadUrl, Convert.FromBase64String(attachment.ContentBytes)); return(folder.WebUrl); } } return(attachmentsUrl); } }
private async Task <IHttpActionResult> SaveAttachmentsWithSsoToken(SaveAttachmentRequest request) { // First retrieve the raw access token var bootstrapContext = ClaimsPrincipal.Current.Identities.First().BootstrapContext as BootstrapContext; if (bootstrapContext != null) { // Use MSAL to invoke the on-behalf-of flow to exchange token for a Graph token UserAssertion userAssertion = new UserAssertion(bootstrapContext.Token); ClientCredential clientCred = new ClientCredential(ConfigurationManager.AppSettings["ida:AppPassword"]); ConfidentialClientApplication cca = new ConfidentialClientApplication( ConfigurationManager.AppSettings["ida:AppId"], ConfigurationManager.AppSettings["ida:RedirectUri"], clientCred, null, null); string[] graphScopes = { "Files.ReadWrite", "Mail.Read" }; AuthenticationResult authResult = await cca.AcquireTokenOnBehalfOfAsync(graphScopes, userAssertion); // Initialize a Graph client GraphServiceClient graphClient = new GraphServiceClient( new DelegateAuthenticationProvider( (requestMessage) => { // Add the OneDrive access token to each outgoing request requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken); return(Task.FromResult(0)); })); foreach (string attachmentId in request.attachmentIds) { var attachment = await graphClient.Me.Messages[request.messageId].Attachments[attachmentId].Request().GetAsync(); // Is this a file or an Outlook item? if (string.Compare(attachment.ODataType, "#microsoft.graph.itemAttachment") == 0) { // Re-request the attachment with the item expanded var itemAttachment = await graphClient.Me.Messages[request.messageId].Attachments[attachmentId].Request() .Expand("microsoft.graph.itemAttachment/item").GetAsync() as ItemAttachment; // Serialize the item to JSON and save to OneDrive string jsonItem = JsonConvert.SerializeObject(itemAttachment.Item); MemoryStream fileStream = new MemoryStream(); StreamWriter sw = new StreamWriter(fileStream); sw.Write(jsonItem); sw.Flush(); fileStream.Position = 0; bool success = await SaveFileToOneDrive(graphClient, itemAttachment.Name + ".json", fileStream); if (!success) { return(BadRequest(string.Format("Could not save {0} to OneDrive", itemAttachment.Name))); } } else { var fileAttachment = attachment as FileAttachment; // For files, we can build a stream directly from ContentBytes if (fileAttachment.Size < (4 * 1024 * 1024)) { MemoryStream fileStream = new MemoryStream(fileAttachment.ContentBytes); bool success = await SaveFileToOneDrive(graphClient, fileAttachment.Name, fileStream); if (!success) { return(BadRequest(string.Format("Could not save {0} to OneDrive", fileAttachment.Name))); } } else { // TODO: Add code here to handle larger files. See: // https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/api/item_createuploadsession // and // https://github.com/microsoftgraph/aspnet-snippets-sample/blob/master/Graph-ASPNET-46-Snippets/Microsoft%20Graph%20ASPNET%20Snippets/Models/FilesService.cs return(BadRequest("File is too large for simple upload.")); } } } return(Ok()); } else { return(BadRequest("Could not retrieve access token from request.")); } }
private async Task <IHttpActionResult> SaveAttachmentsWithDistinctTokens(SaveAttachmentRequest request) { // Validate request if (request == null || !request.IsValid()) { return(BadRequest("One or more parameters is missing.")); } // Initialize a Graph client GraphServiceClient graphClient = new GraphServiceClient( new DelegateAuthenticationProvider( (requestMessage) => { // Add the OneDrive access token to each outgoing request requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", request.oneDriveToken); return(Task.FromResult(0)); })); // First get the attachments from the message // The token we get from the add-in is valid for the Outlook API, // not the Microsoft Graph API. That means we need to invoke the // Outlook endpoint directly, and we can't use the Graph library. // Build the request URI to the message attachments collection string baseAttachmentsUri = request.outlookRestUrl; if (!baseAttachmentsUri.EndsWith("/")) { baseAttachmentsUri += "/"; } baseAttachmentsUri += "v2.0/me/messages/" + request.messageId + "/attachments/"; using (var client = new HttpClient()) { foreach (string attachmentId in request.attachmentIds) { var getAttachmentReq = new HttpRequestMessage(HttpMethod.Get, baseAttachmentsUri + attachmentId); // Headers getAttachmentReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", request.outlookToken); getAttachmentReq.Headers.UserAgent.Add(new ProductInfoHeaderValue("AttachmentsDemoOutlookAddin", "1.0")); getAttachmentReq.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var result = await client.SendAsync(getAttachmentReq); string json = await result.Content.ReadAsStringAsync(); OutlookAttachment attachment = JsonConvert.DeserializeObject <OutlookAttachment>(json); // Is this a file or an Outlook item? if (attachment.Type.ToLower().Contains("itemattachment")) { // Currently REST API doesn't support access to the MIME stream // So for now, just get the JSON representation of the attached item and save it // as a JSON file var getAttachedItemJsonReq = new HttpRequestMessage(HttpMethod.Get, baseAttachmentsUri + attachmentId + "?$expand=Microsoft.OutlookServices.ItemAttachment/Item"); getAttachedItemJsonReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", request.outlookToken); getAttachedItemJsonReq.Headers.UserAgent.Add(new ProductInfoHeaderValue("AttachmentsDemoOutlookAddin", "1.0")); getAttachedItemJsonReq.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var getAttachedItemResult = await client.SendAsync(getAttachedItemJsonReq); Stream jsonAttachedItem = await getAttachedItemResult.Content.ReadAsStreamAsync(); bool success = await SaveFileToOneDrive(graphClient, attachment.Name + ".json", jsonAttachedItem); if (!success) { return(BadRequest(string.Format("Could not save {0} to OneDrive", attachment.Name))); } } else { // For files, we can build a stream directly from ContentBytes if (attachment.Size < (4 * 1024 * 1024)) { MemoryStream fileStream = new MemoryStream(Convert.FromBase64String(attachment.ContentBytes)); bool success = await SaveFileToOneDrive(graphClient, attachment.Name, fileStream); if (!success) { return(BadRequest(string.Format("Could not save {0} to OneDrive", attachment.Name))); } } else { // TODO: Add code here to handle larger files. See: // https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/api/item_createuploadsession // and // https://github.com/microsoftgraph/aspnet-snippets-sample/blob/master/Graph-ASPNET-46-Snippets/Microsoft%20Graph%20ASPNET%20Snippets/Models/FilesService.cs return(BadRequest("File is too large for simple upload.")); } } } } return(Ok()); }
public async Task <string> Authorize([FromBody] SaveAttachmentRequest request) { UserCredential credential; using (var stream = new FileStream("credentials.json", FileMode.Open, FileAccess.Read)) { // The file token.json stores the user's access and refresh tokens, and is created // automatically when the authorization flow completes for the first time. //string credPath = "token.json"; var credPath = System.Web.HttpContext.Current.Server.MapPath("/App_Data/MyGoogleStorage"); credential = GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, Scopes, "user", CancellationToken.None, new FileDataStore(credPath, true)).Result; Console.WriteLine("Credential file saved to: " + credPath); } // Create Drive API service. var service = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = ApplicationName, }); FilesResource.CreateMediaUpload uploadRequest; string childId; string parentId; // Google allows folders with same name. // If the Outlook Attachments already exists, don't create another one var folder = findFolder(service, "Outlook Attachments"); parentId = folder.Id; if (parentId == null) { parentId = createFolderGoogleDrive(service, "Outlook Attachments", null); childId = createFolderGoogleDrive(service, request.subject, parentId); } else { childId = createFolderGoogleDrive(service, request.subject, folder.Id); } /* Start get attachment */ using (var client = new HttpClient()) { // Get content bytes string baseAttachmentUri = request.outlookRestUrl; if (!baseAttachmentUri.EndsWith("/")) { baseAttachmentUri += "/"; } baseAttachmentUri += "v2.0/me/messages/" + request.messageId + "/attachments/"; var i = 0; foreach (string attachmentId in request.attachmentIds) { var getAttachmentReq = new HttpRequestMessage(HttpMethod.Get, baseAttachmentUri + attachmentId); // Headers getAttachmentReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", request.outlookToken); getAttachmentReq.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var result = await client.SendAsync(getAttachmentReq); string json = await result.Content.ReadAsStringAsync(); OutlookAttachment attachment = JsonConvert.DeserializeObject <OutlookAttachment>(json); Google.Apis.Drive.v3.Data.File fileMetaData = new Google.Apis.Drive.v3.Data.File(); fileMetaData.Name = attachment.Name; fileMetaData.Parents = new List <string>(); fileMetaData.Parents.Add(childId); // child folder Id // For files, build a stream directly from ContentBytes if (attachment.Size < (4 * 1024 * 1024)) { MemoryStream stream; using (stream = new MemoryStream(Convert.FromBase64String(attachment.ContentBytes))) { uploadRequest = service.Files.Create( fileMetaData, stream, Format.GetMimeType(attachment.Name)); uploadRequest.Fields = "id"; uploadRequest.Upload(); } try { var file = uploadRequest.ResponseBody; Console.WriteLine("File ID: " + file.Id); } catch (Exception e) { Console.WriteLine(e.Message); } i++; } else { // TODO: Implement functionality to support > 4 MB files } } } /* End get attachment */ return(parentId); }