SharePoint 2013 / 15: September 2015

Sunday 27 September 2015

Sharepoint List items Add attachment & Delete attachments

Adding Items with Attachment

string _Str_File_Name = FileUpload1.PostedFile.FileName;
            byte[] contents = GetFileStream();
            itemId = 0;
            using (SPSite site = new SPSite(SPContext.Current.Web.Url.ToString()))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPList list = web.Lists["Check"];
                    web.AllowUnsafeUpdates = true;
                    SPListItem item = list.Items.Add();
                    item["Title"] = "Title1";
                    item["Citys1"] = "CCC1";
                    if ((_Str_File_Name != null) && (contents.Length > 0))
                    {
                        SPAttachmentCollection fileAttach = item.Attachments;
                        fileAttach.Add(_Str_File_Name, contents);
                    }
                    item.Update();
                    Page.Session["ItemId"] = item.ID;
                    Page.Session["ItemFileName"] = _Str_File_Name;
                    itemId = item.ID;
                    strFileName = _Str_File_Name;
                    Label1.Text = _Str_File_Name + " " + itemId.ToString();
                }
            }
        }
        private byte[] GetFileStream()
        {
            //fuAttachment is your file select control
            if (!FileUpload1.HasFile)
                return null;
            Stream fStream = FileUpload1.PostedFile.InputStream;
            byte[] contents = new byte[fStream.Length];
            fStream.Read(contents, 0, (int)fStream.Length);
            fStream.Close();
            return contents;
        }

Deleting the Attachment / Attachments Only

public static void DeleteAllAttachements(int iid)
        {
            using (SPSite site = new SPSite(SPContext.Current.Web.Url.ToString()))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPListItem listItem = web.Lists["Check"].GetItemById(iid);
                    List<string> fileNames = new List<string>();
                    foreach (string fileName in listItem.Attachments)
                    {
                        fileNames.Add(fileName);
                    }
                    foreach (string fileName in fileNames)
                    {
                        listItem.Attachments.Delete(fileName);
                    }
                    listItem.Update();
                }
            }
        }

//for Update the attachment
            string _Str_File_Name = FileUpload1.PostedFile.FileName;
            byte[] contents = GetFileStream();
            try
            {
                using (SPSite site = new SPSite(SPContext.Current.Web.Url.ToString()))
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        SPList list = web.Lists["Check"];
                        web.AllowUnsafeUpdates = true;
                        // Delete List item
                        // Update the List item by ID
                        SPListItem itemToUpdate = list.GetItemById(31);
                        if ((_Str_File_Name != null) && (contents.Length > 0))
                        {
                            SPAttachmentCollection fileAttach = itemToUpdate.Attachments;
                            fileAttach.Add(_Str_File_Name, contents);
                        }
                        //itemToUpdate["Description"] = "Changed Description";
                        itemToUpdate.Update();
                        Label2.Text = "Udatead the achment pls check";
                    }
                }
            }
            catch (Exception ex)
            {
                Label2.Text = ex.Message;
            }

Programmatically Adding, Deleting, Copying and Downloading Attachments in SPList

1. ADDING AN ATTACHMENT TO AN ITEM IN SPLIST

string _Str_File_Name = FileUpload1.PostedFile.FileName;
            byte[] contents = GetFileStream();
            int itemId = 0;
            using (SPSite site = new SPSite(SPContext.Current.Web.Url.ToString()))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPList list = web.Lists["Check"];
                    web.AllowUnsafeUpdates = true;
                    SPListItem item = list.Items.Add();
                    item["Title"] = "Title1";
                    item["Citys1"] = "CCC1";
                    if ((_Str_File_Name != null) && (contents.Length > 0))
                    {
                        SPAttachmentCollection fileAttach = item.Attachments;
                        fileAttach.Add(_Str_File_Name, contents);
                    }
                    item.Update();
                    itemId = item.ID;
                }
            }

2. DELETING AN ATTACHMENT FROM SPLIST :
private void DeleteAttachment(int NodeID)
{
try
{
SPList myList = SPContext.Current.Web.Lists[“Item List”];
SPListItem delItem = myList.GetItemById(NodeID);
SPAttachmentCollection atCol = delItem.Attachments;
if (delItem[“Attached FileName”] != null)
{
string strFileName = delItem[“Attached FileName”].ToString();
delItem[“Attached FileName”] = string.Empty;
atCol.Delete(strFileName);
delItem.Update();
}
}
catch (Exception eDel)
{
string errDel = eDel.Message;
}
}
3. DOWNLOADING THE ATTACHMENT :

Find the download link first then reedirect to another aspx page so that the response ending on the current page does not affect the functionalities on this :-
private void DownloadAttachment(int NodeID)
{
try
{
string AttachmentURL = string.Empty;
SPList myList = SPContext.Current.Web.Lists[“Item List”];
SPListItem attItem = myList.GetItemById(NodeID);
if (attItem[“Attached FileName”] != null)
{
AttachmentURL = “/Lists/Item%20List1/Attachments/” + NodeID.ToString() + “/” + attItem[“Attached FileName”].ToString();
System.Web.HttpContext.Current.Session[“FileName”] = attItem[“Attached FileName”].ToString();
System.Web.HttpContext.Current.Session[“Attachment”] = AttachmentURL.Trim();
}
else
{
lblReport.Text = GetMessage(110);
}
if (AttachmentURL != string.Empty)
Page.Response.Write(“”);
}
catch (Exception eDwn)
{
string errDwn = eDwn.Message;
}
}
At the aspx page you need to run the code as :
if(System.Web.HttpContext.Current.Session[“Attachment”] != null)
{
string strName = System.Web.HttpContext.Current.Session[“FileName”].ToString();
string sbURL = System.Web.HttpContext.Current.Session[“Attachment”].ToString();
System.Web.HttpResponse response;
response = System.Web.HttpContext.Current.Response;
System.Web.HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.Default;
response.AppendHeader(“Content-disposition”, “attachment; filename=” + strName);
response.AppendHeader(“Pragma”, “cache”);
response.AppendHeader(“Cache-control”, “private”);
response.Redirect(sbURL);
response.End();
}

4. COPYING AN ATTACHMENT FROM ONE ITEM TO ANOTHER IN SPLIST :
private void CopyAttachment(int FromID, int NodeID, string AttachedFile)
{
try
{
SPList myList = SPContext.Current.Web.ParentWeb.Lists[“Item List”];
SPListItem myItem = myList.GetItemById(NodeID);
SPListItem myPrevItem = myList.GetItemById(FromID);
SPAttachmentCollection attColl = myPrevItem.Attachments;
SPFile attFile = myPrevItem.ParentList.ParentWeb.GetFile(myPrevItem.Attachments.UrlPrefix + AttachedFile);
string fileRead = myPrevItem.Attachments.UrlPrefix.ToString() + AttachedFile;
StreamReader fsReader = new StreamReader(attFile.OpenBinaryStream());
Stream fStream = fsReader.BaseStream;
byte[] contents = new byte[fStream.Length];
fStream.Read(contents, 0, (int)fStream.Length);
fStream.Close();
fStream.Dispose();
myItem.Attachments.Add(AttachedFile, contents);
myItem.Update();
}
catch (Exception eCopy)
{
string errCopy = eCopy.Message;
}
}

Wednesday 9 September 2015

How to read SharePoint list items attachments programmatically

SPSite mySite = new SPSite(http://Mohan:8899);
SPWeb myweb = mySite.OpenWeb();
SPList myList = myweb.Lists["Employees"];
SPListItem myListItem = myList.GetItemById(1);
foreach (String attachmentname in myListItem.Attachments)
{
// gets the containing directory URL
String attachmentAbsoluteURL =
myListItem.Attachments.UrlPrefix + attachmentname;

// To get the SPSile reference to the attachment SPFile attachmentFile = myweb.GetFile(attachmentAbsoluteURL);

// To read the file content

   Stream stream = attachmentFile.OpenBinaryStream();
   StreamReader reader = new StreamReader(stream);
   String fileContent = reader.ReadToEnd();

}

Monday 7 September 2015

Develop SharePoint Add-ins

SharePoint Add-ins

Find in-depth articles and resources to help you build advanced capabilities into your SharePoint Add-ins.

Last modified: August 07, 2015
Applies to: apps for SharePoint | Office 365 | SharePoint Add-ins | SharePoint Foundation 2013 | SharePoint Server 2013

Note
The name "apps for SharePoint" is changing to "SharePoint Add-ins". During the transition, the documentation and the UI of some SharePoint products and Visual Studio tools might still use the term "apps for SharePoint". For details, see New name for apps for Office and SharePoint.

In this article
Get started with SharePoint Add-ins resources
Learn the fundamental concepts for development with SharePoint Add-ins
Put the pieces together: Building advanced SharePoint Add-ins by integrating capabilities
Additional resources

Note
This article assumes that you are familiar with the article SharePoint Add-ins and the getting started material that it links to.

Under Develop, we've got the following to help explain all the different things you can do in a SharePoint Add-in:

In-depth overviews
How-to articles
Code snippets

You'll find articles about:

Performing create, read, update, and delete (CRUD) operations on lists
How to build REST queries and interact with the new APIs
How and when to configure OAuth for security

SharePoint has enterprise social features like activity feeds and user profiles, along with enterprise content management features, line-of-business (LOB) interoperability features, and website design features that can really make your add-ins stand out. Learn more about them in Add SharePoint 2013 capabilities.
And, code is key, so take a look at the "Samples" menu in the Dev Center. It's a direct link to our code samples for add-ins. As soon as you've set up your development environment, you should check out a few of our samples. Take advantage of a community feature that lets you request a code sample if we don't have one you'd like to see. We take those requests, along with other doc feedback and use them in our continuous updates to the content and samples. So please, let us know if you'd like to see something!

Get started with SharePoint Add-ins resources

If you're just getting started with developing SharePoint Add-ins, first take a look a SharePoint Add-ins. That page points you to key articles to get you acquainted quickly with the different kinds of SharePoint Add-ins. Before doing more advanced kinds of development with SharePoint Add-ins, you should start with a good idea of the kinds of add-ins that you want to build, the technologies that you will want to include, and the hosting options that you will want to use.

Essential tasks and resources for developing SharePoint Add-ins using the client object model, JavaScript object model, and REST endpoints in SharePoint 2013

No matter what kind of SharePoint Add-in you decide to build, your add-in will always interact in some way with a SharePoint 2013 site. The articles in Table 1 describe how to do many of the most important kinds of work with SharePoint sites by using three interfaces that are available for you to use in your SharePoint Add-ins: the client object model, the JavaScript object model, and REST endpoints.

Table 1. Basic operations with the SharePoint 2013 client object model, JavaScript object model, and REST interface

Topic	Description
Complete basic operations using SharePoint 2013 client library code	Explains how to do common operations by using C# and the client object model.
Complete basic operations using JavaScript library code in SharePoint 2013	Explains how to do common operations by using the JavaScript object model.
Complete basic operations using SharePoint 2013 REST endpoints	Explains how to do common operations by using the REST interface.

Learn the fundamental concepts for development with SharePoint Add-ins

In addition to understanding the basic operations, you should understand the fundamental concepts of the SharePoint 2013 add-in development model. Every kind of SharePoint Add-in contains an add-in manifest file and is built into an add-in package that you deploy to a SharePoint 2013 site. And when you develop any kind of add-in you must consider a range of issues related to authentication and authorization, data access, and usability. The articles in Table 2 acquaint you with these issues and explain their implications for any kind of that you want to create.

Table 2. Fundamental concepts for working with SharePoint Add-ins

Topic	Description
Authorization and authentication of SharePoint Add-ins	Guides you through core concepts related to acquiring the necessary privileges for working with SharePoint 2013 resources.
Explore the app manifest structure and the package of a SharePoint Add-in	Explains how add-in manifests work and how add-in packages are built.
Create UX components in SharePoint 2013	Explores the ways in which you can build a rich user experience in SharePoint Add-ins.
Work with external data in SharePoint 2013	Explains the data access options and techniques that are available in different kinds of SharePoint Add-ins.
License your Office and SharePoint Add-ins	Guides you through the add-in license framework for Office and SharePoint Add-ins.

Put the pieces together: Building advanced SharePoint Add-ins by integrating capabilities

When you are familiar with the capabilities and features of SharePoint Add-ins, you can start building more complex add-ins by putting all of the pieces together in ways that suit your requirements. The articles in Table 3 demonstrate how to integrate capabilities and create more fully featured SharePoint Add-ins.

Table 3. Advanced concepts in SharePoint Add-ins

Topic	Description
Create a provider-hosted add-in that includes a custom SharePoint list and content type	Explains how to create SharePoint Add-ins that are hosted in the cloud and that include custom SharePoint lists and content types.

Additional resources

Complete basic operations using JavaScript library code in SharePoint 2013

In this article

SharePoint 2013 client APIs
Perform basic tasks in SharePoint 2013 using the JavaScript client object model
SharePoint website tasks
SharePoint list tasks
Create, update, and delete lists
Create, update, and delete folders
Create, read, update, and delete files
SharePoint list item tasks
Create, update, and delete list items
Access objects in the host web
Additional resources

You can use the SharePoint client object model to retrieve, update, and manage data in SharePoint 2013. SharePoint makes the object model available in several forms.

.NET Framework redistributable assemblies
JavaScript library
REST/OData endpoints
Windows Phone assemblies
Silverlight redistributable assemblies

The following sections describe tasks that you can complete programmatically, and they include JavaScript code examples that demonstrate the operations.
When you create a cloud-hosted add-in, you can add a reference to the object model by using HTML <script> tags. We recommend that you reference the host web because the add-in web may not exist in every scenario in cloud-hosted add-ins. You can retrieve the host web URL from the SPHostUrl query string parameter if you are using the {StandardTokens} token. You can also use your custom defined query string parameter if you are using the {HostUrl} token. After you have the host web URL, you must use JavaScript code to dynamically create the reference to the object model.
The following code example performs these tasks to add a reference to the JavaScript object model:

References the AJAX library from the Microsoft Content Delivery Network (CDN).
References the jQuery library from the Microsoft CDN.
Extracts the host web URL from the query string.
Loads the SP.Runtime.js and SP.js files by using the getScript function in jQuery. After loading the files, your program has access to the JavaScript object model for SharePoint.
Continues the flow in the execOperation function.

References the AJAX library from the Microsoft CDN.
References the SP.Runtime.js file by using a URL relative to the add-in web.
References the SP.js file by using a URL relative to the add-in web.

Use the Include method to access properties of ListItem objects

Four properties of ListItem objects are not available by default when you return list items—displayName, effectiveBasePermissions, hasUniqueRoleAssignments, and roleAssignments. The previous example returns a PropertyOrFieldNotInitializedException if you try to access one of these properties. To access these properties, use the Include method as part of the query string, as shown in the following example.

function retrieveListItemsInclude(siteUrl) {
    var clientContext = new SP.ClientContext(siteUrl);
    var oList = clientContext.get_web().get_lists().getByTitle('Announcements');
    var camlQuery = new SP.CamlQuery();
    camlQuery.set_viewXml('<View><RowLimit>100</RowLimit></View>');
    this.collListItem = oList.getItems(camlQuery);
    clientContext.load(
        collListItem,
        'Include(Id, DisplayName, HasUniqueRoleAssignments)'
    );
    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.onQuerySucceeded),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function onQuerySucceeded(sender, args) {
    var listItemInfo = '';
    var listItemEnumerator = collListItem.getEnumerator();

    while (listItemEnumerator.moveNext()) {
        var oListItem = listItemEnumerator.get_current();
        listItemInfo += '\nID: ' + oListItem.get_id() +
            '\nDisplay name: ' + oListItem.get_displayName() +
            '\nUnique role assignments: ' +
            oListItem.get_hasUniqueRoleAssignments();
    }
    alert(listItemInfo.toString());
}
function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() +
        '\n' + args.get_stackTrace());
}

Create a list item

function createListItem(siteUrl) {
    var clientContext = new SP.ClientContext(siteUrl);
    var oList = clientContext.get_web().get_lists().getByTitle('Announcements');

    var itemCreateInfo = new SP.ListItemCreationInformation();
    this.oListItem = oList.addItem(itemCreateInfo);
    oListItem.set_item('Title', 'My New Item!');
    oListItem.set_item('Body', 'Hello World!');
    oListItem.update();
    clientContext.load(oListItem);
    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.onQuerySucceeded),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function onQuerySucceeded() {
    alert('Item created: ' + oListItem.get_id());
}
function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() +
        '\n' + args.get_stackTrace());
}

Update a list item

function updateListItem(siteUrl) {
    var clientContext = new SP.ClientContext(siteUrl);
    var oList = clientContext.get_web().get_lists().getByTitle('Announcements');
    this.oListItem = oList.getItemById(3);
    oListItem.set_item('Title', 'My Updated Title');
    oListItem.update();
    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.onQuerySucceeded),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function onQuerySucceeded() {
    alert('Item updated!');
}
function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() +
        '\n' + args.get_stackTrace());
}

Delete a list item

function deleteListItem(siteUrl) {
    this.itemId = 2;
    var clientContext = new SP.ClientContext(siteUrl);
    var oList = clientContext.get_web().get_lists().getByTitle('Announcements');
    this.oListItem = oList.getItemById(itemId);
    oListItem.deleteObject();
    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.onQuerySucceeded),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function onQuerySucceeded() {
    alert('Item deleted: ' + itemId);
}
function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() +
        '\n' + args.get_stackTrace());
}

If you want to retrieve, for example, the new item count that results from a delete operation, include a call to the update() method to refresh the list. In addition, you must load either the list object itself or the itemCount property on the list object before executing the query. If you want to retrieve both a start and end count of the list items, you must execute two queries and return the item count twice, as shown in the following modification of the previous example.

function deleteListItemDisplayCount(siteUrl) {
    this.clientContext = new SP.ClientContext(siteUrl);
    this.oList = clientContext.get_web().get_lists().getByTitle('Announcements');
    clientContext.load(oList);
    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.deleteItem),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function deleteItem() {
    this.itemId = 58;
    this.startCount = oList.get_itemCount();
    this.oListItem = oList.getItemById(itemId);
    oListItem.deleteObject();
    oList.update();
    clientContext.load(oList);

    clientContext.executeQueryAsync(
        Function.createDelegate(this, this.displayCount),
        Function.createDelegate(this, this.onQueryFailed)
    );
}
function displayCount() {
    var endCount = oList.get_itemCount();
    var listItemInfo = 'Item deleted: ' + itemId +
        '\nStart Count: ' + startCount +
        ' End Count: ' + endCount;

    alert(listItemInfo)
}
function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() +
        '\n' + args.get_stackTrace());
}

While developing your add-in, you might need to access the host web to interact with items in it. Use the AppContextSite object to reference the host web or other SharePoint sites, as shown in the following example. For a full code sample, see Get the host web title using the cross-domain library (JSOM).

function execCrossDomainRequest(appweburl, hostweburl) {
    // context: The ClientContext object provides access to
    //      the web and lists objects.
    // factory: Initialize the factory object with the
    //      add-in web URL.
    var context;
    var factory;
    var appContextSite;
    context = new SP.ClientContext(appweburl);
    factory = new SP.ProxyWebRequestExecutorFactory(appweburl);
    context.set_webRequestExecutorFactory(factory);
    appContextSite = new SP.AppContextSite(context, hostweburl);
    this.web = appContextSite.get_web();
    context.load(this.web);
    // Execute the query with all the previous
    // options and parameters.
    context.executeQueryAsync(
        Function.createDelegate(this, successHandler),
        Function.createDelegate(this, errorHandler)
    );
    // Function to handle the success event.
    // Prints the host web's title to the page.
    function successHandler() {
        alert(this.web.get_title());
    }
    // Function to handle the error event.
    // Prints the error message to the page.
    function errorHandler(data, errorCode, errorMessage) {
        alert("Could not complete cross-domain call: " + errorMessage);
    }
}