using System;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using System.Data;
using Microsoft.Office.Server;
using Microsoft.Office.Server.Search;
using Microsoft.Office.Server.Search.Query;

namespace Apress.SP2010.Layouts.CustomSearch
{
    public partial class ApplicationPage1 : LayoutsPageBase
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                SetGridColumns();
            }
        }

        // The event is called when the search button is pressed
        protected void btnSearch_Click(object sender, EventArgs e)

{
            DataTable search = new DataTable();
            using (SPSite site = new SPSite(SPContext.Current.Web.Site.Url))
            {
                KeywordQuery query = new KeywordQuery(site);
                query.ResultsProvider = Microsoft.Office.Server.Search.Query.
                                                       SearchProvider.Default;
                query.ResultTypes = ResultType.RelevantResults;
                query.KeywordInclusion = KeywordInclusion.AllKeywords;
                query.QueryText = txtSearch.Text;
                ResultTableCollection results = query.Execute();

                if (results.Count > 0)
                {
                    ResultTable relevant = results[ResultType.RelevantResults];
                    search.Load(relevant);

                    DataView view = new DataView(search);
                    // Fill the SPGridView defined in the page markup
                    searchGrid.DataSource = search;
                    searchGrid.DataBind();
                }
            }
        }

        private void SetGridColumns()
        {

            SPBoundField fieldTitle = new SPBoundField();
            fieldTitle.HeaderText = "Title";
            fieldTitle.DataField = "Title";
            SearchGrid.Columns.Add(fieldTitle);

            SPBoundField fieldPath = new SPBoundField();
            fieldPath.HeaderText = "Path";
            fieldPath.DataField = "Path";
            SearchGrid.Columns.Add(fieldPath);

            SPBoundField fieldAuthor = new SPBoundField();
            fieldAuthor.HeaderText = "Edited";
            fieldAuthor.DataField = "Write";
            SearchGrid.Columns.Add(fieldAuthor);
        }
    }
}

public void GetColleaguesFromUserProfile()
{
   // Get the current site context
   strUrl = "http://localhost";
   SPSite site = new SPSite(strUrl);
   SPServiceContext serviceContext = SPServiceContext.GetContext(site);

   // Initialize the user profile manager
   UserProfileManager upm = new UserProfileManager(serviceContext);

   // Create a user profile
   string sAccount = "domain\bpehlke";
   if (!upm.UserExists(sAccount))
        upm.CreateUserProfile(sAccount);

   // Get the colleagues from user profile
   UserProfile u = upm.GetUserProfile(sAccount);
   foreach (var colleague in u.Colleagues.GetCommonColleagues())
   {
      lbColleagues.Items.Add(colleague.DisplayName);
   }
}

public void GetChangesForUserProfile()
{
   //get current service context
   strUrl = "http://localhost";
   SPSite site = new SPSite(strUrl);
   SPServiceContext serviceContext = SPServiceContext.GetContext(site);

   //initialize user profile manager
   UserProfileManager upm = new UserProfileManager(serviceContext);

   //get the changes for the user profile
   string sAccount = "domain\bpehlke";
   UserProfile u = upm.GetUserProfile(sAccount);
   foreach (var change in u.GetChanges())
   {
    lblOutput.Text += "<br>" + change.ChangeType + " "
                             + change.ChangedProfile + " "
                             + change.EventTime.ToShortDateString();
   }
}

public void CreatePersonalSite()
{
   //get current service context
   SPServiceContext serviceContext = SPServiceContext.Current;

   //initialize user profile config manager
   UserProfileManager upm = new UserProfileManager(serviceContext);
   string currentUser = "domain\bpehlke";
   UserProfile up = upm.GetUserProfile(currentUser);
   up.CreatePersonalSite();
   SPSite mysite = up.PersonalSite;

   using (SPWeb web = mysite.OpenWeb())
   {
     //do something in the My Site context
   }
}

public void CreatePersonalSite()
{
   //get current service context

SPServiceContext serviceContext = SPServiceContext.Current;

   //initialize user profile manager
   UserProfileManager upm = new UserProfileManager(serviceContext);
   string currentUser = "domain\bpehlke";
   UserProfile u = upm.GetUserProfile(currentUser);

   //get a list of all user profile properties
   foreach (var prop in u.Properties)
   {
       lblOutput.Text += "<br>" + prop.DisplayName;
   }
   //set the department property
   string department= "IT-Services";
   u[PropertyConstants.Department].Add(department);
   u.Commit();
   //read the new department value
   lblOutput.Text += "<br>" + "New department value: "
                            + u[PropertyConstants.Department].Value.ToString();
}

PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{

throw new System.ArgumentException(
                     "The SPWeb " + web.Title + " is not a PublishingWeb", "web");
}

PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(web);
string pageName = "MyTestPage.aspx";

PageLayout[] pageLayouts = publishingWeb.GetAvailablePageLayouts();
PageLayout currPageLayout =  pageLayouts[0];

PublishingPageCollection pages = publishingWeb.GetPublishingPages();
PublishingPage newPage = pages.Add(pageName,currPageLayout);

newPage.ListItem[FieldId.PublishingPageContent] = "This is my content";
newPage.ListItem.Update();
newPage.Update();
newPage.CheckIn("This is just a comment");

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint.Publishing.Administration;

namespace Apress.Sp2010.DeploymentAPI
{
    public class Program
    {
        static void Main( string[] args )
        {
            Example example = new Example();
            example.Invoke();
        }
    }

    public class Example
    {
        public void Invoke()
        {
            // Path settings
            string pathName = "My Deployment Path";
            Uri sourceServerUri = new Uri( "http://serverA" );
            string sourceSiteCollection = "/sites/SC1";

            Uri destinationAdminUri = new Uri( "http://serverB:50000" );
            Uri destinationServerUri = new Uri( "http://serverB" );
            string destinationSiteCollection = "/sites/SC2";

            // Job settings
            string jobName = "My Content Deployment Job";

            ContentDeploymentPath path = null;
            ContentDeploymentJob job = null;

            try
            {
                // Note: the DESTINATION farm must be configured
                // to accept incoming deployment jobs.
                ContentDeploymentConfiguration config =
                            ContentDeploymentConfiguration.GetInstance();

config.AcceptIncomingJobs = true;
                config.RequiresSecureConnection = false;
                config.Update();

                // Create a deployment path.
                ContentDeploymentPathCollection allPaths =
                            ContentDeploymentPath.GetAllPaths();
                path = allPaths.Add();

                path.Name = pathName;
                path.SourceServerUri = sourceServerUri;
                path.SourceSiteCollection = sourceSiteCollection;
                path.DestinationAdminServerUri = destinationAdminUri;
                path.DestinationServerUri = destinationServerUri;
                path.DestinationSiteCollection = destinationSiteCollection;
                path.Update();

                // Create a job associated with the path
                job = ContentDeploymentJob.GetAllJobs().Add();
                job.JobType = ContentDeploymentJobType.ServerToServer;
                job.Name = jobName;
                job.Path = path;
                job.Update();
                job.Run();
            }
            catch ( Exception ex )
            {
                Console.Error.WriteLine( ex.StackTrace );
                throw;
            }
            finally
            {
                // Delete the job that was created.
                if ( job != null ) job.Delete();

                // Delete the path that was created.
                if ( path != null ) path.Delete();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;

namespace Apress.SP2010.CheckinCheckout
{
    class Program
    {
        static void Main(string[] args)
        {
            using (SPSite site = new SPSite("http://sharepointserve"))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPDocumentLibrary docs =
                           (SPDocumentLibrary)web.Lists["DocumentSilo"];
                    foreach (SPFile file in docs.RootFolder.Files)
                    {
                        if (file.CheckOutType == SPFile.SPCheckOutType.None)
                        {
                            file.CheckOut();
                        }
                    }
                    // Added, but not yet checked in.
                    foreach (SPCheckedOutFile file in docs.CheckedOutFiles)

{
                        Console.WriteLine(file.LeafName);
                    }
                    // Checked out regularly.
                    var checkedout = from f in
                                          docs.RootFolder.Files.OfType<SPFile>()
                                     where f.CheckOutType ==
                                          SPFile.SPCheckOutType.Online
                                     select f;
                    foreach (var file in checkedout)
                    {
                        Console.WriteLine(file.Name);
                    }
                    // Check in and add a comment.
                    foreach (SPFile file in docs.RootFolder.Files)
                    {
                        if (file.CheckOutType != SPFile.SPCheckOutType.None)
                        {
                            file.CheckIn("Programmatically Checked In");
                        }
                    }
                }
            }
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;

namespace Apress.SP1010.Versioning
{
    class Program
    {

static void Main(string[] args)
        {
            using (SPSite site = new SPSite("http://sharepointserve"))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPList docs = web.Lists["DocumentSilo"];
                    Console.WriteLine("Versioning is active: ",
                                        docs.EnableVersioning);
                    foreach (SPFile file in docs.RootFolder.Files)
                    {
                        Console.WriteLine("File {0} has next
                                           version {1}. Version History:",
                            file.Url,
                            file.UIVersionLabel);
                        foreach (SPFileVersion v in
                                 file.Versions.Cast<SPFileVersion>().Reverse())
                        {
                            Console.WriteLine("  Version {0} checked in
                                                 at {1} with this comment: '{2}'",
                                v.VersionLabel,
                                v.Created,
                                v.CheckInComment);
                        }
                    }
                }
            }
            Console.ReadLine();
        }
    }
}

static void MoveDocumentToRecordsCenter()
{
   try
   {
      string additionalInformation = string.Empty;
      OfficialFileResult operationResult;

      using (SPSite mySite = new SPSite("http://ServerName"))
      {

  using(SPWeb myWeb = mySite.OpenWeb())
  {
                     SPFile myDoc = myWeb.GetFile("DocLib/DocName.docx");
            operationResult =
                 myDoc.SendToOfficialFile(out additionalInformation);

            Console.WriteLine("Operation State: " + operationResult);

  }
      }
   }
   catch (Exception ex)
   {
      Console.WriteLine("Error - " + ex.ToString());
   }
}

using Microsoft.Office.RecordsManagement.PolicyFeatures;
using Microsoft.Office.RecordsManagement.InformationPolicy;

public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
   string xmlManifest;
   TextReader policyStream = new
       StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(
                   "Apress.SP2010.RMPolicies.policy.xml"));
       xmlManifest = policyStream.ReadToEnd();
       PolicyResource.ValidateManifest(xmlManifest);
       PolicyResourceCollection.Add(xmlManifest);
}

<PolicyResource
      xmlns="urn:schemas-microsoft-com:office:server:policy"
      id = "CustomExpiration.CustomExpirationFormula"
      featureId="Microsoft.Office.RecordsManagement.PolicyFeatures.Expiration"
      type = "DateCalculator">
  <Name>Apress Filtered Expiration</Name>
  <Description>Items expires based on a filtered critereon.</Description>
    <AssemblyName>Apress.RMPolicies, Version=1.0.0.0,
       Culture=neutral,PublicKeyToken=44050b881185bf1b</AssemblyName>
   <ClassName>Apress.RMPolicies.FilteredExpiration</ClassName>
</PolicyResource>

public class FilteredExpiration : IExpirationFormula
{
   #region IExpirationFormula Members
   public DateTime? ComputeExpireDate(SPListItem item,
                                       System.Xml.XmlNode parametersData)

{
      if (item["DeleteNow"].ToString().Equals("Yes"))
      {
          return DateTime.Now;
      }
      else
      {
          return null;
      }
   }
   #endregion
}