/// <summary> /// Detaches the operation. /// </summary> /// <param name="commonResponse">Common response object</param> /// <param name="clientContext">Client context object</param> /// <param name="list">List object</param> /// <param name="listItems">List item collection object</param> /// <returns>Returns Common response object</returns> internal static CommonResponse DetachOperation(CommonResponse commonResponse, ClientContext clientContext, List list, ListItemCollection listItems) { CommonResponse detachOperationResponse = new CommonResponse(); try { ContentType targetDocumentSetContentType = BriefcaseContentTypeHelperFunctions.GetContentType(list, clientContext); if (null != targetDocumentSetContentType) { foreach (var listItem in listItems) { listItem[ServiceConstantStrings.OneDriveSiteColumn] = string.Empty; listItem[ConstantStrings.OneDriveContentTypeProperty] = Convert.ToString(targetDocumentSetContentType.Id, CultureInfo.InvariantCulture); listItem.Update(); clientContext.ExecuteQuery(); commonResponse.Status.Add(true); } detachOperationResponse = commonResponse; } } catch (Exception exception) { Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName); } return(detachOperationResponse); }
/// <summary> /// Determines whether the content type exists in the content type group under the specified client context. /// </summary> /// <param name="clientContext">Client context</param> /// <param name="web">Object of site</param> /// <param name="receivedContentType">Type of the received content</param> /// <param name="contentTypeGroup">The content type group</param> /// <param name="siteColumns">List of site columns</param> internal static bool IsContentTypePresentCheck(ClientContext clientContext, Microsoft.SharePoint.Client.Web web, string receivedContentType, string contentTypeGroup, List <string> siteColumns) { bool status = true; try { ContentTypeCollection contentTypeCollection = web.ContentTypes; clientContext.Load(contentTypeCollection, contentTypes => contentTypes.Include(contentTypeProperties => contentTypeProperties.Group, contentTypeProperties => contentTypeProperties.Name).Where(contentTypeValues => (contentTypeValues.Group == ServiceConstantStrings.OneDriveContentTypeGroup) && (contentTypeValues.Name == ServiceConstantStrings.OneDriveContentTypeName))); clientContext.ExecuteQuery(); if (0 < contentTypeCollection.Count) { FieldCollection fields = contentTypeCollection[0].Fields; clientContext.Load(fields, field => field.Include(fieldType => fieldType.Title).Where(column => column.Title == ServiceConstantStrings.OneDriveSiteColumn)); clientContext.ExecuteQuery(); if (0 == fields.Count) { BriefcaseContentTypeHelperFunctions.AddColumnsToContentType(web, siteColumns, contentTypeCollection[0]); web.Update(); clientContext.ExecuteQuery(); } } else { status = BriefcaseContentTypeHelperFunctions.CreateContentType(clientContext, web, siteColumns, receivedContentType, contentTypeGroup); } } catch (Exception exception) { status = false; Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName); } return(status); }
/// <summary> /// Uploads the document to matter library. /// </summary> /// <param name="requestObject">Request Object containing SharePoint App Token</param> /// <param name="sourceUrl">URL of the source document</param> /// <param name="documentStream">Content stream of the document</param> /// <param name="versionInfo">The version information.</param> /// <param name="comments">The comments.</param> /// <param name="retainCheckOut">retain check out option</param> /// <returns>Content Type List for the Request Object containing SharePoint App Token</returns> internal static string UploadtoMatter(RequestObject requestObject, string sourceUrl, Stream documentStream, int versionInfo, string comments, bool retainCheckOut) { string status = ConstantStrings.FALSE; string result = ConstantStrings.FALSE; try { if (null != requestObject) { ClientContext clientContext; if (!string.IsNullOrWhiteSpace(sourceUrl) && null != documentStream) { string[] sourceUrlParts = sourceUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture)); if (2 == sourceUrlParts.Length) { using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(sourceUrlParts[0]), requestObject.RefreshToken)) { Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(sourceUrlParts[1]); string documentLibraryName = BriefcaseHelperFunction.getLibraryName(clientContext, file); string contentType = string.Empty; contentType = BriefcaseContentTypeHelperFunctions.ContentTypeByName(requestObject, clientContext, file.Name, sourceUrl, 1, contentType, documentLibraryName); string listContentType = BriefcaseContentTypeHelperFunctions.GetContentTypeList(requestObject, clientContext, sourceUrl, contentType, 1, documentLibraryName); status = BriefcaseContentTypeHelperFunctions.GetContentTypeList(requestObject, clientContext, sourceUrl, contentType, 2, documentLibraryName); FileSaveBinaryInformation fileSaveBinaryInformation = new FileSaveBinaryInformation(); fileSaveBinaryInformation.ContentStream = documentStream; file.SaveBinary(fileSaveBinaryInformation); // Check if file is already checked out if (file.CheckOutType == CheckOutType.None) { file.CheckOut(); } // Check the type of Check in to be performed switch (versionInfo) { case 0: file.CheckIn(comments, CheckinType.MinorCheckIn); break; case 1: file.CheckIn(comments, CheckinType.MajorCheckIn); break; case 2: file.CheckIn(comments, CheckinType.OverwriteCheckIn); break; } // Load the Stream data for the file clientContext.ExecuteQuery(); status = BriefcaseContentTypeHelperFunctions.GetContentTypeList(requestObject, clientContext, sourceUrl, listContentType, 2, documentLibraryName); // Check whether we need to retain checkout if (retainCheckOut) { file.CheckOut(); clientContext.ExecuteQuery(); } status = string.Concat(ConstantStrings.TRUE, ConstantStrings.Comma, ConstantStrings.Space, file.ServerRelativeUrl); } } result = status; } else { status = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ConstantStrings.Space, TextConstants.MissingParametersMessage); result = status; } } } catch (Exception exception) { status = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ConstantStrings.Space, ServiceUtility.RemoveEscapeCharacter(exception.Message)); result = status; } return(result); }
/// <summary> /// Uploads the document to OneDrive (Users MySite document library). /// </summary> /// <param name="requestObject">Request Object containing SharePoint App Token</param> /// <param name="collectionOfAttachments">Collection of documents with data for each document</param> /// <param name="collectionOfOriginalAttachments">Collection of documents with path of source document</param> /// <param name="usersMySite">User's My site URL</param> /// <param name="allAttachmentUrl">Attachment URL.</param> /// <param name="isOverwrite">Overwrite check</param> /// <returns>JSON string specifying path of OneDrive as success and false as failure</returns> internal static string UploadtoBriefcase(RequestObject requestObject, Dictionary <string, Stream> collectionOfAttachments, Dictionary <string, string> collectionOfOriginalAttachments, string usersMySite, string[] allAttachmentUrl, int isOverwrite) { string status = ConstantStrings.FALSE; try { using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(usersMySite), requestObject.RefreshToken)) { Microsoft.SharePoint.Client.Web web = clientContext.Web; string contentType = ServiceConstantStrings.OneDriveContentTypeName; // Get Content Type string contentTypegroup = ServiceConstantStrings.OneDriveContentTypeGroup; // Get Group of Content Type List <string> siteColumns = new List <string>(new string[] { ServiceConstantStrings.OneDriveSiteColumn }); bool isSiteColumnCreated = BriefcaseContentTypeHelperFunctions.CreateSiteColumn(clientContext, web, siteColumns); if (isSiteColumnCreated) { bool isContentTypeCreated = BriefcaseContentTypeHelperFunctions.IsContentTypePresentCheck(clientContext, web, contentType, contentTypegroup, siteColumns); if (isContentTypeCreated) { List list = web.Lists.GetByTitle(ServiceConstantStrings.OneDriveDocumentLibraryTitle); string briefcaseFolderQuery = string.Format(CultureInfo.InvariantCulture, ServiceConstantStrings.BriefcaseFolderQuery, ServiceConstantStrings.LegalBriefcaseFolder); ListItemCollection listItems = Lists.GetData(clientContext, ServiceConstantStrings.OneDriveDocumentLibraryTitle, briefcaseFolderQuery); BriefcaseContentTypeHelperFunctions.SetContentType(clientContext, list, usersMySite); string defaultContentTypeId = BriefcaseContentTypeHelperFunctions.SetOneDriveDefaultContentType(clientContext, list, contentType); if (ConstantStrings.FALSE != defaultContentTypeId) { web.Update(); if (0 == isOverwrite) { MailAttachmentDetails.CheckoutFailedPosition = 0; status = BriefcaseUtilityHelperFunctions.NewDocumentToOneDrive(clientContext, collectionOfAttachments, collectionOfOriginalAttachments, allAttachmentUrl, web, usersMySite, defaultContentTypeId); //// Undo check out in case of failure //// undo checkout all documents from position MailAttachmentDetails.checkOutFailedPosition BriefcaseHelperFunction.DiscardDocumentCheckout(requestObject, allAttachmentUrl); } else { MailAttachmentDetails.CheckoutFailedPosition = 0; status = BriefcaseUtilityHelperFunctions.OverWriteDocument(collectionOfAttachments, collectionOfOriginalAttachments, usersMySite, status, clientContext, web, listItems, defaultContentTypeId); string[] returnedStatus = status.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture)); if (ConstantStrings.TRUE == returnedStatus[0]) { BriefcaseHelperFunction.DiscardDocumentCheckout(requestObject, allAttachmentUrl); } status = returnedStatus[1]; } } else { MatterCenterException customException = new MatterCenterException(TextConstants.ErrorCodeAssignDefaultContentType, TextConstants.ErrorMessageAssignDefaultContentType); throw customException; // Throw will direct to current function's catch block (if present). If not present then it will direct to parent catch block. Parent will be the calling function } } else { MatterCenterException customException = new MatterCenterException(TextConstants.ErrorCodeCreateSiteContentType, TextConstants.ErrorMessageCreateSiteContentType); throw customException; // Throw will direct to current function's catch block (if present). If not present then it will direct to parent catch block. Parent will be the calling function } } else { MatterCenterException customException = new MatterCenterException(TextConstants.ErrorCodeCreateSiteColumn, TextConstants.ErrorMessageCreateSiteColumn); throw customException; // Throw will direct to current function's catch block (if present). If not present then it will direct to parent catch block. Parent will be the calling function } } } catch (Exception exception) { Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName); status += ConstantStrings.Semicolon + usersMySite; } return(status); }