1. Open Visual Studio 2010 Shell which comes with SQL Server 2012 (formerly “BIDS”), Choose New Project >> "Report Server Project Wizard" type, Give it a name.
2. This opens Report Project Wizard. Click Next
3. We've to create a Data source for our report. Choose "New data source", Give it a name and choose Type. In my case, data is in SQL Server. Click on "Edit" button to specify SQL Server database
4. From the connection Properties dialog box, Specify the Server Name and Database in which our required data live
5. Now, We get the connection string for our data source. Click on Next
6. Click on "Add Table" icon from Query Designer, Choose the Tables query, Click on "Add"
7. Pick the columns to use in the Report. Click on OK.
8. Now we got the query to use in our reports. Click on Next.
9. Move fields to relevant sections, such as on Page, Group, and on Report Details section.
10. Choose the deployment location. In our case its our SharePoint site. Enter Report server as our SharePoint site URL and Deployment Folder as any existing document library URL in our SharePoint site.
11. Finally, Give a Name to the report. Click on Finish.
12. One last but not least step is: Go to Project Properties >> Set the Target Locations. Say we've a document library called "Reports" in our SharePoint site. Specify the document library’s full path here. (Set all attributes!)

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

#Get all SharePoint content databases available
$ContentDatabases = Get-SPContentDatabase
#Loop through each content database
 foreach($ContentDb in $ContentDatabases)
  {
   Write-Host "`nContent Database Name:  $($ContentDb.Name) Size:$($ContentDb.DiskSizeRequired/1MB) MB " -ForegroundColor DarkGreen
 #Get all site collections in the content database
 Write-Host "Site Collections List:" -ForegroundColor Blue
 foreach($site in $ContentDb.Sites)
 {
  write-host $site.url
 }
  } 

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

 #Set the Content Database Name
 $ContentDbName = "SP2010_SharePoint_ContentDB"
 #Get the Content Database
 $ContentDb = Get-SPContentDatabase -Identity $ContentDbName
  #Iterate through each site collection in the Content database
  foreach($site in $ContentDb.Sites)
 {
  write-host $site.url
 }

1. Go to Library Setting >> Advance Settings >> Select Yes for “Allow management of content types” and click on Yes.
2. This Navigates to library settings again. Scroll down and Click on “Add from existing site content types” under “Content Types”
3. Add “Report Builder Report” content type, and click on “OK”.

• Monitor your Server RAM usage. Try closing some programs running on the server.
• Restart "Search Host Controller Service" service in Services console (services.msc)
• Perform IISReset on SharePoint wFE(s)
• Make sure anonymous authentication enabled for SharePont web application in IIS
• Run IE with out any Add-ons. You can also try using browsers other than IE (Try with Firefox/Chrome)
• If Security Token Service is in stopped state, Start it. Try recycling it, if its already started.

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

#Function to Check if an User exists in AD
function CheckUserExistsInAD()
   {
   Param( [Parameter(Mandatory=$true)] [string]$UserLoginID )  
  #Search the User in AD
  $forest = [System.DirectoryServices.ActiveDirectory.Forest]::GetCurrentForest()
  foreach ($Domain in $forest.Domains)
  {
   $context = new-object System.DirectoryServices.ActiveDirectory.DirectoryContext("Domain", $Domain.Name)
         $domain = [System.DirectoryServices.ActiveDirectory.Domain]::GetDomain($context)
   $root = $domain.GetDirectoryEntry()
         $search = [System.DirectoryServices.DirectorySearcher]$root
         $search.Filter = "(&(objectCategory=User)(samAccountName=$UserLoginID))"
         $result = $search.FindOne()
          if ($result -ne $null)
         {
           return $true
         }
  }
  return $false  
 }

 #Get All site collections of all web applications
 $sites = Get-SPWebApplication | Get-SPSite -Limit All
 #Iterate through each site collection
 foreach($site in $sites)
 { 

 Write-Host "Processing Site:"$site.Url -ForegroundColor Magenta
  foreach($Web in $site.AllWebs)
 {
  #Arrays to Hold Orphaned Alerts & Users
   $OrphanedAlerts = @()
  $AlertUsers  = @()
  #Get all Alerts created on the web
  $WebAlerts = $web.Alerts 
  #Get Unique Users from All Alerts 
  $AlertUsers = $web.Alerts | foreach { $_.User } | Select-Object -Unique

  #Check if any user with alerts is :Orphan!
  if($AlertUsers.length -gt 0)
  {
   foreach($AlertUser in $AlertUsers)
    {
     #Write-host "Checking User:"$AlertUser
     #Check if the user is valid - Not Orphan
     $UserName = $AlertUser.UserLogin.split("\")  #Get User Name from : Domain\UserName
     $AccountName = $UserName[1]    #UserName
                     if ((CheckUserExistsInAD $AccountName) -eq $false)
                     {
      $OrphanedAlerts+=$AlertUser.Alerts
      }
    }
   if($OrphanedAlerts.Length -gt 0) 
    { 
     Write-Host "Total No. of Orphaned Alerts Found:" $OrphanedAlerts.Length  -ForegroundColor Red
     #Delete each orphaned alert
     foreach ($OrphAlert in $OrphanedAlerts)
     {
      write-host "`nOrphaned Alert:" $OrphAlert.ID" on "$web.Url "List:" $OrphAlert.ListUrl "User:"$OrphAlert.User
      Write-Host "Deleting Orphaned Alert..."
      #$WebAlerts.Delete($OrphAlert.ID)
     }
    }
   }     
 }
 }

#$WebAlerts.Delete($OrphAlert.ID)

• Step 1: Drop a mail to "SharePoint.Crescent@gmail.com" with subject "jQuery Rotating Banner for SharePoint" to get the complete source code jQuery-Rotating-Banner.zip instantly! This zip file contains all scripts, style sheets and sample images for the banner. Extract them to your local folder.
• Step 2: Create a new picture library (or even document library can do!), name it as "banner", Open the library in explorer view and upload all files including "images" folder and its files extracted from the jQuery-Rotating-Banner.zipfile.
  Important: Make sure all of your SharePoint site users granted at least "Read" access to the banner library!
• Step 3: Create a new Hyperlink column in your banner library, name it as "Target"
• Step 4: Go to "images" folder under your banner library, set the target URL for the banners, So that when users click on the rotating banner images, they'll be redirected to respective pages.
• Step 5: Edit banner.htm and style.css files: Find and replace the hard coded link: "http://sharepoint.crescent.com" with your SharePoint site's URL where you created "banner" library.
• Step 6: Add a content editor web part, Edit web part properties, Specify the content link as the "banner.htm" file which is located in the "banner" library.

<!DOCTYPE HTML>
<html>
<head>
<title>jQuery Rotating Banner coded by http://www.SharePointDiary.com</title>

<link href="http://sharepoint.crescent.com/banner/style.css" rel="stylesheet" type="text/css">
<script type="text/javascript" src="http://sharepoint.crescent.com/banner/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="http://sharepoint.crescent.com/banner/jquery.cycle.all.js"></script>
<script type="text/javascript" src="http://sharepoint.crescent.com/banner/jquery.easing.1.3.js"></script>
<script type="text/javascript" src="http://sharepoint.crescent.com/banner/jquery.backgroundpos.js"></script>

<script type="text/javascript">
$(window).bind("load", function() {
 setTimeout(function() {
     $('.slideshow').cycle({ 
    fx:    'scrollHorz', 
    delay: 0,
    speed:  500,
    rev: 0,
    next:  '.nextArrow',
    prev:   '.prevArrow'
});
}, 2000);
});

    $(document).ready(function() {
     var soapEnv =
            "<soapenv:Envelope xmlns:soapenv='http://schemas.xmlsoap.org/soap/envelope/'> \
<soapenv:Body> \
<GetListItems xmlns='http://schemas.microsoft.com/sharepoint/soap/'> \
<listName>banner</listName> \
<viewFields> \
<ViewFields> \
<FieldRef Name='Title' /> \
<FieldRef Name='Target' /> \
</ViewFields> \
</viewFields> \
<queryOptions> \
<QueryOptions> \
<ViewAttributes Scope='RecursiveAll'/> \
<Folder>http://sharepoint.crescent.com/banner/images</Folder> \
</QueryOptions> \
</queryOptions> \
</GetListItems> \
</soapenv:Body> \
</soapenv:Envelope>";

        $.ajax({
            url: "http://sharepoint.crescent.com/_vti_bin/lists.asmx",
            type: "POST",
            dataType: "xml",
            data: soapEnv,
            complete: processResult,
            contentType: "text/xml; charset=\"utf-8\""
        });
    });

    function processResult(xData, status) {
        $(xData.responseXML).find("z\\:row").each(function() {
   //Get Images from "Images" Folder          
  var Html=" <a href='" + $(this).attr("ows_Target").split(',')[0] +"'><img src='http://sharepoint.crescent.com/banner/images/" + $(this).attr("ows_FileLeafRef").substring($(this).attr("ows_FileLeafRef").indexOf('#')+1, $(this).attr("ows_FileLeafRef").length ) + "'></a>";

        $("#slideimages").append(Html);

        });
    }

</script>
</head>
<body>
<div id="mainWrap">
<div class="banner">
<div class="innerWrap">
<div class="slideshow" id="slideimages"> 
</div>
<div class="prevArrow"></div>
<div class="nextArrow"></div>
</div>
</div>       
</div>
</body>
</html>

• Open the web.config in Notepad
• Search for "CallStack", Change it from "false" to "true"
• Search for "CustomErrors mode", Change its value from "On" to "Off"
• Save and Close.

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

Function ConfigureCustomError()
 {
  Param( [Parameter(Mandatory=$true)] [string]$WebAppURL,  [parameter(Mandatory=$true)] $Option )
<#
  .Description
  This PowerShell function Enables / Disables SharePoint Custom Error by editing web.config file
 .Example
  ConfigureCustomError "http://sharepoint.crescent.com" "OFF"
  This disables SharePoint's default custom error page and reveals actual error
 .Link
  http://www.sharepointdiary.com
  http://twitter.com/SharePointdiary
 .Inputs
  $WebAppURL - Web Application URL in which the Custom Errors to be set 
  $Option - ON or OFF
 .Outputs
  Sets "CustomErrors mode" and "CallStack" values in web.config file
 #>

 #Get the web application
 $WebApp = Get-SPWebApplication $WebAppURL
 #Get the Web Application Zone
 $Zone = $WebApp.AlternateUrls[0].UrlZone
 # Get the IIS settings for the zone
 $IISSettings = $WebApp.IISSettings[$zone]
 # Get the path from the settings
 $WebConfigPath = $IISSettings.Path.ToString() + "\web.config"

 #Backup web.config file
 $now = [datetime]::now.ToString('dd-MM-yyyy hh-mm-ss')
 $BackupFile =$IISSettings.Path.ToString()+ "\web.config.$now"
 copy-item $WebConfigPath -destination $BackupFile

 #Get the Web.config File
 $XMLDoc = new-object System.Xml.XmlDocument
 $XMLDoc.Load($WebConfigPath)
  switch($option)
  {
  "OFF" { 
    #Apply Change
    $XMLDoc.get_DocumentElement()."sharepoint".safemode.callstack = "True"
    $XMLDoc.get_DocumentElement()."system.web".customErrors.mode = "Off"
    Write-Host "Custom Error Mode has been Disabled, Now you can get the actual errors!"
    }
  "ON" {
    $XMLDoc.get_DocumentElement()."sharepoint".safemode.callstack = "False"
    $XMLDoc.get_DocumentElement()."system.web".customErrors.mode = "ON"
    Write-Host "Custom Error Mode has been Enabled, SharePoint displays default custom error Page!"
    }
  }
 $XMLDoc.Save($WebConfigPath)
 }
 #Call the function to Turn OFF custom errors
 ConfigureCustomError "http://sharepoint.crescent.com" "OFF"

Add-PSSnapin Microsoft.sharepoint.powershell -ErrorAction SilentlyContinue

$WebAppURL = "http://sharepoint.crescent.com"

#Get all content databases of the web application 
$ContentDbs = Get-SPContentDatabase -WebApplication $WebAppURL

#Create maintenance Window Object
$MaintenanceWindow = New-Object Microsoft.SharePoint.Administration.SPMaintenanceWindow
$MaintenanceWindow.MaintenanceEndDate    = "12/31/2013 11:59:00 PM"
$MaintenanceWindow.MaintenanceStartDate  = "12/29/2013 12:00:00 AM"
$MaintenanceWindow.NotificationEndDate   = "12/31/2013 11:59:00 AM"
$MaintenanceWindow.NotificationStartDate = "12/25/2013 08:00:00 AM"
$MaintenanceWindow.MaintenanceType       = "MaintenancePlanned"  #Another Option: MaintenanceWarning
$MaintenanceWindow.Duration              = "03:00:00:00" #in "DD:HH:MM:SS" format
$MaintenanceWindow.MaintenanceLink       = "http://support.crescent.com/faq/SPMaintenanceWindow"

#Add Maintenance window for each content database of the web application
$ContentDbs | ForEach-Object  {
 #Clear any existing maintenance window
 $_.MaintenanceWindows.Clear()

 #Add New Maintenance Window
 $_.MaintenanceWindows.add($MaintenanceWindow)
    $_.Update() 
 }

$ContentDbs = Get-SPContentDatabase

Get-SPContentDatabase | foreach-object {
    $_.MaintenanceWindows.Clear()
    $_.Update()
 }

1. Central Administration >> Application Management >> Manage Service Applications
2. Click on the "Search Service Application" link, Which takes you to Search Administration page.
3. Click on "Query Rules" link from left navigation.
4. SharePoint 2013 Query Rules section seems bit confusing at the first look.
5. Select a Result Source as "Local SharePoint Results" and Click on "New Query Rule" link.
6. Give a Rule Name. Say, "HR Policies". Under Query conditions select "Query Matches Keyword Exactly" and enter Phrases as "HR Policies; HR Policy". Under "Actions" section, click on "Add Promoted Results" Link.
7. Provide promoted result specifications, such as Result Title, URL, Description. Click on Save" button once done. Promoted results also can point to any document, list/librariy item as well.
8. Optionally, You can enable Publishing based on dates (When should the rule be active?)
9. Click the "Save" button in the promoted results page and in the Query Rules Page.

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

##################################################################################
##  VARIABLES SECTION ##
##################################################################################

$LibraryURLs = @("https://intranet.Crescent.com/sites/IT/docs/", "https://intranet.Crescent.com/sites/operations/inventory/", "https://intranet.Crescent.com/sites/Sales/documents")

### Variables for Email setup
#URL of the Site where the SharePoint group exists
$EmailGroupSite = "https://intranet.Crescent.com/sites/IT/"
#Name of the SharePoint Group to which emails to be sent
$EmailGroupName= "Report Group"

#Internal Name of the Column which stores the expiration date of documents
$ExpiryDateColumnInternalName = "Expiration_x0020_Date0"
#How to get the Internal name of a SharePoint Column? 
#Refer http://www.sharepointdiary.com/2011/06/sharepoint-field-display-name-vs-internal-name.html

#Site URL where the tracking list "Document Expiration Monitor - Tracking" to be maintained 
$TrackingSiteURL = "https://intranet.Crescent.com/sites/IT/"

$ExpiryDays = 7  

$SMTPServer = "smtp.Crescent.com"

$EmailFrom = "DocumentExpiryMonitor@YOURCOMPANY.com"
$EmailSubject = "Document Expiration Monitor Report as on $(Get-Date)"

#Region Functions
###############################################################################
##  FUNCTIONS ##
###############################################################################

#Functions for Get-SPSite & Get-Web in MOSS 2007
function global:Get-SPSite($url) {
    return new-Object Microsoft.SharePoint.SPSite($url)
 } 

function global:Get-SPWeb($url) {
  $site= New-Object Microsoft.SharePoint.SPSite($url)
        if($site -ne $null) {
               $web=$site.OpenWeb();        
            }
    return $web
} 

#Validate the Web at given URL
function Validate-Web($WebURL)
 { 
  try {
    $web = Get-SPWeb $WebURL
    return $web
      }
  catch {
    $Message = "Error in Site URL:$WebURL. Please provide valid Site URL!"
    Write-Host $Message -ForegroundColor red
    Append-LogMessage $Message $error[0]

    #Continue executing code
    continue

    return $null
   }
 }

#Validate the Web at given URL
function Validate-SPSite($SiteURL)
 { 
  try {
    $Site = Get-SPSite $SiteURL
    return $Site
      }
  catch {
    $Message = "Error in Site Collection URL:$SiteURL."
    Write-Host $Message -ForegroundColor red
    Append-LogMessage $Message $error[0]

    #Continue executing code
    continue

    return $null
   }

 }
#Function to validate given List URL 
 function Validate-List($ListURL)
 { 
  try {
    $list = $web.GetList($ListURL)
    return $list
      }
  catch {
    $Message = "Error in List URL: $ListURL! Please provide valid List URL!"
    Write-Host $Message -ForegroundColor red
    Append-LogMessage $Message $error[0]

    #Continue executing code
    continue

    return $null
   }
 }

function Send-Email ($EMailBody, $EmailTo) {
 try {
    #Send the Mail
    $MailMessageParameters = @{
   SmtpServer = $SMTPServer
      Subject = $EmailSubject 
      Body = $EmailBody 
      From = $EmailFrom 
      To =  $EmailTo 
      }
    Send-MailMessage @MailMessageParameters -BodyAsHtml
   Append-LogMessage "Email has been sent to :"$EmailTo
 }
 catch {
  Write-Host "Error sending email, Please check log file!" -ForegroundColor Red
  Append-LogMessage $error[0]
 }
}

#Function to Get the Location where script is located
function GetScriptDir
{
 $Invocation = (Get-Variable MyInvocation -Scope 1).Value
 return Split-Path $Invocation.MyCommand.Path
}

#Extract Emails from each user in a Group
function Get-GroupEmails()
{
 try {
  $Emails=@()
  $Site = Validate-SPSite $EmailGroupSite
   if($site -ne $null)
   {
    $Group = $site.RootWeb.sitegroups | Where {$_.Name -match $EmailGroupName}
    #$Group= $web.SiteGroups[$GroupName]   
    if($Group -ne $null)
    {     
     $Users = $Group.Users
        foreach ($User in $Users)
                 {
         if( ($user.Email -ne "") -and ($user.Email -ne $null) )
         { 
          $Emails+=$user.Email
         }
        }
      $Emails =  $Emails -split ","   
      return $Emails
    }
    else
    {
     $Message = "E-mail Group Name:$EmailGroupName Not found!"
     Write-Host $Message -ForegroundColor red
     Append-LogMessage $Message $error[0]
     return $null
    }
   }
  }
  catch {
    $Message = "Error in Get-GroupEmails Function!"
    Write-Host $Message -ForegroundColor red
    Append-LogMessage $Message $error[0]

    #Continue executing code
    continue

    return $null
   }  
  }

#Function to Log details to Tracking List
function LogTo-TrackingList($EmailBody)
{
 $web = Validate-Web $TrackingSiteURL
 if($web -eq $null) 
 {
  # Creating base file to append to, adding a new line for readability
  $Message = "Tracking Site URL is not valid!"
  Write-Host $Message -ForegroundColor Red
  Append-LogMessage $Message
  return
 } 

 #Try to Get the "Tracking List"
 $TrackingList = $web.Lists | Where { $_.Title -match "Document Expiration Monitor - Tracking"}

 #If Tracking list doesnt exist, Create it
 if($TrackingList -eq $null)
 {
  #Create New Tracking List
  $TrackingListID = $Web.Lists.Add("DEMTracking","List to Track Document Expiration Monitor Mails",[Microsoft.SharePoint.SPListTemplateType]::GenericList)
  #Set Name for the List
  $TrackingList = $web.Lists[$TrackingListID]
  $TrackingList.Title="Document Expiration Monitor - Tracking"
  $TrackingList.update()

  #Rename the "Title Field" to Tracking ID
  $TitleField = $TrackingList.Fields.GetFieldByInternalName("Title")
  #Set Field Display Name and Update
  $TitleField.Title ="Tracking Date"
  $TitleField.Update()

  #Add Email Body Field 
  $EmailBodyField = $TrackingList.Fields.Add("Email Body","Note",$true)
  $trackingList.Fields["Email Body"].RichText = $True
  $trackingList.Fields["Email Body"].RichTextMode = "FullHtml"
  $trackingList.Fields["Email Body"].update()

 }
    #Add New Item to Tracking List
    $item = $TrackingList.Items.Add()
    #Set the Tracking Date & Email Body field values
    $item["Email Body"] = $EmailBody 

    #Set the Tracking Date field
    $item["Tracking Date"] = $TodaysDate
    $item.update()

   #Log details to Tracking List
   $web.dispose()

}

# Appends text to the log message
function Append-LogMessage($text) 
{
 Add-Content $LogTextFileName $text"`r" -Encoding UTF8 
}

#EndRegion

#Variables for Internal processing
$ScriptPath = GetScriptdir

#Get the Template HTM File with CSS
$MailContent = Get-Content -Path "$ScriptPath\template.htm" -Encoding UTF7 | Out-String

$CAMLDateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"
$DateFormat = "MM/dd/yyyy"

$TodaysDate = Get-date
$TodaysDateFormatted = (Get-date).ToString($CAMLDateFormat) 
$ExpirationDate = (Get-Date).AddDays($ExpiryDays)
$ExpirationDateFormatted = (Get-Date).AddDays($ExpiryDays).ToString($CAMLDateFormat) 
$LogTextFileName = "$ScriptPath\DEM_LOG.txt"
$Message =""

# Creating base file to append to, adding a new line for readability
$Message = "Script Execution Started at $TodaysDate." >> $LogTextFileName
Write-Host $Message -ForegroundColor DarkGreen
Append-LogMessage $Message

###############################################################################
##  PROCESS EACH DOCUMENT LIBRARY AND SEND EMAIL ##
###############################################################################

 ########## Process "Expiring Documents" ###########
 $MailContent+= "<h2> Document Expiry Monitor - Report as on : $(Get-Date) </h2>"
 $ExpiringContentHeader =  "<h3 style='color: #333399;'> List of Expiring Documents: </h3> <table class='altrowstable' cellpadding='5px' cellspacing='5'><tr><th>Document Name </th><th>Created By</th><th>Created on</th><th> Expiry Date </th><th> URL </th></tr>"
 $MailContent += $ExpiringContentHeader 
 $ExpiringContent=""
 $ExpiredContent=""

# Loop through items and Get all Expiring Documents
 foreach ($ListURL in $LibraryURLs) 
 { 
  #Get the web 
  $web = Validate-Web $ListURL

  if($web -eq $null) {
   #Skip the current list and proceed with the next from array
   continue
  }

  #Get the List
  $list = Validate-List $ListURL
  if($list -eq $null) {
   #Skip the current list and proceed with the next from array
   continue
  }

 #Check if the list has the "Expiration Date" Column
 if ($list.Fields.GetFieldByInternalName($ExpiryDateColumnInternalName) -eq $false)
 {
  $Message = "$ListURL does not contains Expiration Date Field specified!"
  Write-Host $Message -ForegroundColor red
  Append-LogMessage $Message

  #Skip the current list and proceed with the next from array
  continue
 }

 # Write out the dates we're looking for
 $Message = "Searching $ListURL for Expiring documents with Expiration Date between " + $TodaysDate + " - " + $ExpirationDate
 Write-Host $Message -ForegroundColor DarkGreen
 Append-LogMessage $Message

 # Get all Expiring Documents
 $ExpiringQuery = '<Where><And><Geq><FieldRef Name="' + $ExpiryDateColumnInternalName + '" /><Value Type="DateTime" IncludeTimeValue="True">' + $TodaysDateFormatted + 

'</Value></Geq><Leq><FieldRef Name="' + $ExpiryDateColumnInternalName + '" /><Value Type="DateTime" IncludeTimeValue="True">' + $ExpirationDateFormatted + '</Value></Leq></And></Where>'
 $SPExpiringQuery = new-object Microsoft.SharePoint.SPQuery
    $SPExpiringQuery.ViewAttributes = "Scope='Recursive'"
 $SPExpiringQuery.Query = $ExpiringQuery
 $ExpiringListItems = $List.GetItems($SPExpiringQuery)
 $Message = "Found " + $ExpiringListItems.Count + " Expired document(s)."
 Write-Host $Message -ForegroundColor DarkGreen
 Append-LogMessage $Message

 #If There are some expiring documents found
  if($ExpiringListItems.Count -gt 0)
  {    
   foreach($Item in $ExpiringListItems)
   {
    $ExpiringContent+= "<tr> <td> $($item.Name)  </td> <td> $($item.File.Author.Name)  </td> <td> $($item.File.TimeCreated.ToString($DateFormat)) </td> <td> $($Item

[$ExpiryDateColumnInternalName].ToString($DateFormat)) </td>  <td> <a href='$($web.URL)/$($item.URL)'>$($web.URL)/$($item.URL)</a> </td> </tr>"
   }
  }
 }
 if($ExpiringContent.Length -eq 0)
 {
  $ExpiringContent+= "<tr> <td colspan=5> No Expiring Documents Found! </td> </tr>"
 }
 $ExpiringContent+= "</table><br/>" 

 $MailContent += $ExpiringContent

 ########## Process "Expired Documents " ###########
 $ExpiredContentHeader =  "<h3 style='color: #660033;'> List of Expired Documents: </h3> <table class='altrowstable' cellpadding='5px' cellspacing='5'><tr><th>Document Name </th><th>Created 

By</th><th>Created on</th><th> Expiry Date </th><th> URL </th></tr>"
  $MailContent += $ExpiredContentHeader 

 $ExpiredContent=""
# Loop through items and Get all Expired Documents
 foreach ($ListURL in $LibraryURLs) 
 { 
  if($web -eq $null) {
   #Skip the current list and proceed with the next from array
   continue
  }

  #Get the List
  $list = Validate-List $ListURL
  if($list -eq $null) {
   #Skip the current list and proceed with the next from array
   continue
  }

 #Check if the list has the "Expiration Date" Column
 if ($list.Fields.GetFieldByInternalName($ExpiryDateColumnInternalName) -eq $false) 
 {
  $Message = "$ListURL does not contains Expiration Date Field specified!"
  Write-Host $Message -ForegroundColor red
  Append-LogMessage $Message

  #Skip the current list and proceed with the next from array
  continue
 }

 # Write out the dates we're looking for
 $Message = "Searching $ListURL for Expired documents with Expiration Date between " + $TodaysDate + " - " + $ExpirationDate
 Write-Host $Message -ForegroundColor DarkGreen
 Append-LogMessage $Message

 # Get all Expired Documents
 $ExpiredQuery = '<Where><Lt><FieldRef Name="' + $ExpiryDateColumnInternalName + '" /><Value Type="DateTime" IncludeTimeValue="True">' + $TodaysDateFormatted + '</Value></Lt></Where>'
 $SPExpiredQuery = new-object Microsoft.SharePoint.SPQuery
    $SPExpiredQuery.ViewAttributes = "Scope='Recursive'"
 $SPExpiredQuery.Query = $ExpiredQuery
 $ExpiredListItems = $List.GetItems($SPExpiredQuery)

 $Message = "Found " + $ExpiredListItems.Count + " Expired document(s)."
 Write-Host $Message -ForegroundColor DarkGreen
 Append-LogMessage $Message 

 #If There are some expired documents found
  if($ExpiredListItems.Count -gt 0)
  {    
   foreach($Item in $ExpiredListItems)
   {
    $ExpiredContent+= "<tr> <td> $($item.Name) </td> <td> $($item.File.Author.Name) </td> <td> $($item.File.TimeCreated.ToString($DateFormat)) </td> <td> $($Item

[$ExpiryDateColumnInternalName].ToString($DateFormat)) </td>  <td> <a href='$($web.URL)/$($item.URL)'>$($web.URL)/$($item.URL)</a> </td> </tr>"
   }
  }
 }
 if($ExpiredContent.Length -eq 0)
 {
  $ExpiredContent+= "<tr> <td colspan=5> No Expired Documents Found! </td> </tr>"
 }
 $ExpiredContent+= "</table><br/>" 


 $MailContent += $ExpiredContent
 $MailContent += "</body></html>"

 #Email the Body 
 $EmailAddresses = Get-GroupEmails
 if($EmailAddresses -ne $null)
 {
  Send-Email $MailContent $EmailAddresses 
 }

 #Log to Tracking table
 LogTo-TrackingList $MailContent

###############################################################################
##  CLEAN UP ##
###############################################################################

# Log end of processing
$Message = "Finished Processing Document Expiration Monitor Script by $(Get-Date)."
Write-Host $Message -ForegroundColor DarkGreen
Append-LogMessage $Message

# Dispose of the web object
$web.Dispose()

<html>
<head> 
<!-- CSS goes in the document HEAD or added to your external stylesheet -->
<style type="text/css">
body{
font-family: Calibri;
 height: 12pt;
}
table.altrowstable {
 border-collapse: collapse;
 font-family: verdana,arial,sans-serif;
 font-size:11px;
 color:#333333;
 border-width: 1px;
 border-color: #a9c6c9;
 border: b1a0c7 0.5pt solid;  
}
table.altrowstable th {
 border-width: 1px;
 padding: 5px;
 background-color:#8064a2;
 border: #b1a0c7 0.5pt solid;
 font-family: Calibri;
 height: 15pt;
 color: white;
 font-size: 11pt;
 font-weight: 700;
 text-decoration: none;
}
table.altrowstable td {
 border: #b1a0c7 0.5pt solid; font-family: Calibri; height: 15pt; color: black; font-size: 11pt; font-weight: 400; text-decoration: none;
}
</style>
</head>
<body>

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

#Display name of the Timer Job to Run on-demand
$TimerJobName = "Health Analysis Job"

#Get the Timer Job
$TimerJobs = Get-SPTimerJob | where { $_.DisplayName -match $TimerJobName}

foreach($TimerJob in $TimerJobs) 
 {
    Write-Host "Running:" $TimerJob.DisplayName
    $TimerJob.RunNow()
 }

Get-SPTimerJob | where { $_.DisplayName -match "Health Analysis Job"} | % { Start-SPTimerJob $_ ; Write-Host "Runing Job:" $_.displayName } # 

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

#Functions to Imitate SharePoint 2010 Cmdlets in MOSS 2007
function global:Get-SPWebApplication($WebAppURL)
 { 
  return [Microsoft.SharePoint.Administration.SPWebApplication]::Lookup($WebAppURL)
 }

function global:Get-SPSite($url) {
    return new-Object Microsoft.SharePoint.SPSite($url)
 } 

function global:Get-SPWeb($url) {
  $site= New-Object Microsoft.SharePoint.SPSite($url)
        if($site -ne $null) {
               $web=$site.OpenWeb();        
            }
    return $web
} 

#Get all site collections of the provided web application
$WebApp = Get-SPWebApplication "https://intranet.crescent.com"
$SitesCollection = $WebApp.Sites

$UsageDataCollection = @()
 #Iterate through each site collection
 ForEach($site in $SitesCollection)
 {
    $web = Get-SPWeb $site.URL
    $LastMonthUsage = ($web.GetUsageData("url", "lastMonth") | sort 'Total Hits')
    If($LastMonthUsage -ne $null)
 { 

     $totalHits = ($LastMonthUsage | Measure-Object 'Total Hits' -Sum | Select -expand Sum)     

        $UsageDataResult = New-Object PSObject
        $UsageDataResult | Add-Member -type NoteProperty -name "Site Collection URL" -value $site.URL
        $UsageDataResult | Add-Member -type NoteProperty -name "Site Title" -value $web.title
        $UsageDataResult | Add-Member -type NoteProperty -name "Total Hits" -value $totalHits

        $UsageDataCollection += $UsageDataResult

  #Clear variables
     $LastMonthUsage = $null
     $tHits = $null
    }
 }

 $UsageDataCollection | sort-object "Total Hits" -descending | select-object -first 10 | Export-csv "Top10Sites.csv" -notypeinformation

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

    #Set the Terms to add in Search Suggestions
    $SearchSuggestions = @("Crescent", "Crescent Policies", "Crescent News", "Crescent Tech", "Crescent Employee Of the Month", "Crescent Travel Request")

    #Get the Search Service Application "Search Service Application" - Your's may be in different name
    $ssa = Get-SPEnterpriseSearchServiceapplication -Identity "Search Service Application" 

    #Process Each Search Term
    foreach ($Suggestion in $SearchSuggestions)
    {
        New-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $ssa -Language en-US -Type QuerySuggestionAlwaysSuggest -Name $Suggestion
    }

    #Trigger the Timerjob
    $timerJob = Get-SPTimerJob "Prepare query suggestions"
    $timerJob.RunNow()

$csvfile = "D:\SearchSuggestions.csv" #with header "Suggestion"
$KeyWordsData = Import-Csv $csvfile
...

foreach ($Row in $KeywordsData)
{
  New-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $ssa -Language en-US -Type QuerySuggestionAlwaysSuggest -Name $Row.Suggestion
}
...

#Get the Search Service Application "Search Service Application" by its name
$ssa = Get-SPEnterpriseSearchServiceapplication -Identity "Search Service Application" 
#Get all  Search Query suggestion
Get-SPEnterpriseSearchQuerySuggestionCandidates -SearchApplication $ssa

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

#Get the Search Service Application "Search Service Application" by its name
$ssa = Get-SPEnterpriseSearchServiceapplication -Identity "Search Service Application" 

#Remove Search Query Suggestion "Crescent Employee Of the Month"
Remove-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $ssa -Language En-Us -Type QuerySuggestionAlwaysSuggest -Identity "Crescent Employee Of the Month"

#Trigger the Timerjob for the changes to take effect
$timerJob = Get-SPTimerJob "Prepare query suggestions"
$timerJob.RunNow()

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

#Set the Terms to add in Search Suggestions
$SearchSuggestions = @("Crescent", "Crescent Policies", "Crescent News", "Crescent Tech", "Crescent Employee Of the Month", "Crescent Travel Request")

#Get the default search service application
$ssa = Get-SPEnterpriseSearchServiceApplication
#You can also use: Get-SPEnterpriseSearchServiceapplication -Identity "Search Service Application" 

$owner = Get-SPEnterpriseSearchOwner -level SSA

#Process Each Search Term
foreach ($Suggestion in $SearchSuggestions)
{
   New-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $ssa -Language En-Us -Type QuerySuggestionAlwaysSuggest -Name $Suggestion -Owner $owner
}
#Trigger the SharePoint 2013 query suggestions timer job
Start-SPTimerJob -Identity "Prepare query suggestions"

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

#Get the default search service application
$ssa = Get-SPEnterpriseSearchServiceApplication

#Set the Query Suggestion Level
$owner = Get-SPEnterpriseSearchOwner -level SSA

#Get All Existing phrases
$SuggestionList = Get-SPEnterpriseSearchLanguageResourcePhrase  -SearchApplication $ssa -Owner $Owner -Language En-Us -Type QuerySuggestionAlwaysSuggest #-SourceId $ResultSource.Id

#Remove Them All
$SuggestionList |  Remove-SPEnterpriseSearchLanguageResourcePhrase -Type QuerySuggestionAlwaysSuggest -Language "en-us" -Owner $Owner 

#Trigger the SharePoint 2013 query suggestions timer job
Start-SPTimerJob -Identity "Prepare query suggestions"

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

#Set the Terms to add in Search Suggestions
$SearchSuggestions = @("Crescent", "Crescent Policies", "Crescent News", "Crescent Tech", "Crescent Employee Of the Month", "Crescent Travel Request")

#Get the default search service application
$ssa = Get-SPEnterpriseSearchServiceApplication

$Web = Get-SPweb -Identity "http://sharepoint.crescent.com/sites/operations/"

$owner = Get-SPEnterpriseSearchOwner -Level SPWeb -SPWeb $web 

$FederationManager  = New-Object Microsoft.Office.Server.Search.Administration.Query.FederationManager –ArgumentList $ssa

$ResultSource = $FederationManager.GetSourceByName("Local SharePoint Results", $owner)

#Process Each Search Term
foreach ($Suggestion in $SearchSuggestions)
{
   New-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $ssa -Language En-Us -Type QuerySuggestionAlwaysSuggest -Name $Suggestion -Owner $owner -SourceId $ResultSource.Id
}

#Its also  possible to use PowerShell to Import Search Suggestions from text file using PowerShell
#$ssap = Get-SPEnterpriseSearchServiceApplicationProxy
#Import-SPEnterpriseSearchPopularQueries -SearchApplicationProxy $ssap -Filename "D:\querySuggestions.txt" -ResultSource $source -Web $web

#Trigger the timer job
Start-SPTimerJob -Identity "Prepare query suggestions"

1. Use "Single Line of Text" instead of "Number" column type, if possible. (But this will not stop users from entering alpha characters!)
2. Use an another Calculated column with formula: = TEXT( Number_Column_Name, "0") . If you need sorting, you can use: =FIXED(Number_Column_Name,0,TRUE) 
   
3. Add Integer field programmatically (As there is no interface to do this!)
   

   #Get all site collections of the provided web application
   $Web = Get-SPWeb "http://projects.crescent.com/sites/Corp"
   
   $ListName = "ProjectBudget"
   
   $list = $web.lists[$ListName]
   
   $list.Fields.Add("TotalValue", [Microsoft.SharePoint.SPFieldType]::Integer, $false)
   

4. If its for a view, You can use Dataview/XSLT web part with "format-number" formula as: <xsl:value-of select='format-number(TotalValue,"#.00") '/>

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

$WebAppUrl = "http://sharepoint.crescent.com" #Read-Host "Enter Web Application URL:"
$rootSite = New-Object Microsoft.SharePoint.SPSite($WebAppUrl)

#Get the Web Application from Site Collection
$WebApp = $rootSite.WebApplication

foreach($site in $WebApp.Sites)
{
    Write-Host "$($Site.Url) - $($Site.Owner) : $($Site.Owner.Email)"
    $site.Dispose()
}

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

Get-SPWebApplication "http://sharepoint.crescent.com" | Get-SPSite | foreach-object { Write-host $_.Url - $_.Owner.Email}

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

Get-SPSite -Filter {$_.Owner -EQ "Global\Salaudeen"} -limit 100

Get-SPFeature | Sort-Object Scope | Format-Table -GroupBy scope

Get-SPFeature | Sort -Property Scope, DisplayName | Ft -Autosize -GroupBy Scope DisplayName, Id > D:\FeaturesReport.txt

Get-SPFeature -WebApplication "web-app-url"
#Similarly:
#Get-SPFeature -Farm
#Get-SPFeature -Site $Site.URL
#Get-SPFeature -Web $web.URL

Get-SPFeature | Format-Table @{Label='ID';Expression={$_.Id}}, 
@{Label='DisplayName';Expression={$_.DisplayName}}, 
@{Label='Title';Expression={$_.GetTitle(1033)}}, 
@{Label='Scope';Expression={$_.Scope}} -AutoSize | Out-File -Width 250 
D:\AllFeatures.txt

Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue

$siteurl = "http://sharepoint.crescent.com"

Get-SPFeature -Limit ALL -Site $siteurl | ForEach-Object {
 $data = @{ 
  Feature = $_.GetTitle(1033)
  Description = $_.GetDescription(1033)
    }
 New-Object PSObject -Property $data; 
} | Select-Object Feature, Description 

Add-PSSnapin Microsoft.SharePoint.Powershell -ErrorAction SilentlyContinue

$FeatureName = "TemplateDiscovery"
#We can also use "FeatureID" instead of Feature DisplayName 

# Get all Farm scoped features
#write-host "Farm scoped features:"
#Get-SPFeature -Farm 

# To Search for a specific Farm scoped feature:
Get-SPFeature -Farm | where { $_.DisplayName -eq $FeatureName } #Eg SpellChecking

 #Process All Web Applications
 ForEach ($WebApp in Get-SPWebApplication)
 {
 write-host "`nProcessing Web Application:" $webapp.url  
 #Get All Web Application Scoped features 
 #Get-SPFeature -WebApplication $WebApp.url 

 # To Search for a specific WebApplication scoped feature:
 Get-SPFeature -WebApplication $WebApp.url | where { $_.DisplayName -eq $FeatureName }

    #Process each site collection
  foreach ($site in $WebApp.sites) 
  {
  write-host "`tProcessing Site Collection: " $site.url 
  #Get All Site collection Scoped features 
  #Get-SPFeature -Site $site.url 

  # To Search for a specific Site Collection scoped feature:
  Get-SPFeature -Site $site.url | where { $_.DisplayName -eq $FeatureName }

      #Process each site
      foreach ($web in $site.AllWebs) 
      {
     write-host "`t`tProcessing Web: " $web.url 
     # Get All Web scoped features
     #Get-SPFeature -Web $web 

     # To Search for a specific Site Collection scoped feature:
     Get-SPFeature -Web $web | where { $_.DisplayName -eq $FeatureName }
       }
  }
 }

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

Function global:Get-SPWebApplication($WebAppURL)
{
 return [Microsoft.SharePoint.Administration.SPWebApplication]::Lookup($WebAppURL)
}

  #Get the SharePoint Farm. Equallent to : Get-SPFarm commandlet
  $Farm = [Microsoft.SharePoint.Administration.SPFarm]::Local

  #Get All feature of the farm. Equallent to: Get-SPFeature commandlet
  $FarmFeatures= $Farm.FeatureDefinitions

  $WebAppURL = "http://SharePoint.Crescent.com"
  $WebApp = Get-SPWebApplication $WebAppURL

   #Scan Web Application Features
    Write-Host  "Features Activated at Web Application Level:"  -ForegroundColor DarkGreen

   foreach($feature in $WebApp.Features)
   {
      #Write-Host $feature.DefinitionId;
      Write-Host $farmfeatures[$feature.DefinitionId].DisplayName 
   }

  #Get All site collections of the Web Application  
  $SitesColl = $webApp.Sites  

  #Iterate through each site collection/sub-site
  foreach($Site in $SitesColl)
  {
   Write-Host "`nFeatures Activated at SITE:" $site.Url -ForegroundColor DarkGreen

   #Iterate through each feature activated at Site collection level
   foreach($feature in $site.Features)
   {
      #Write-Host $feature.DefinitionId;
      Write-Output $farmfeatures[$feature.DefinitionId].DisplayName;
   }
    foreach($web in $site.AllWebs)
    {
          Write-Host "`nFeatures Activated at WEB:" $web.Url -ForegroundColor DarkGreen
    #Iterate through each feature activated at web level
      foreach($Feature in $web.Features)
          {
        Write-Output $FarmFeatures[$Feature.DefinitionId].DisplayName;
     #Write-Output $FarmFeatures[$Feature.DefinitionId].GetTitle(1033);
          }
  }
  }

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

  #Get the SharePoint Farm. Equallent to : Get-SPFarm commandlet
  $Farm = [Microsoft.SharePoint.Administration.SPFarm]::Local

  #Get All feature of the farm. Equallent to: Get-SPFeature commandlet
  $FarmFeatures= $Farm.FeatureDefinitions
  $FarmFeatures | Select ID,DisplayName, Scope | Sort-Object Scope | Format-Table -GroupBy Scope

#Get-SPWebApplication Cmdlet for MOSS 2007
Function global:Get-SPWebApplication($WebAppURL)
{  
   if($WebAppURL -eq $null)  #Get All Web Applications
    {
  $Farm = [Microsoft.SharePoint.Administration.SPFarm]::Local
    $websvcs = $farm.Services | where -FilterScript {$_.GetType() -eq [Microsoft.SharePoint.Administration.SPWebService]}
    $WebApps = @()
    foreach ($websvc in $websvcs) 
  {
      foreach ($WebApp in $websvc.WebApplications) 
   {
          $WebApps += $WebApp
      }
  }
   return $WebApps
  }
 else #Get Web Application for given URL
 {
  return [Microsoft.SharePoint.Administration.SPWebApplication]::Lookup($WebAppURL)
 }
}

  #Get the SharePoint Farm. Equallent to : Get-SPFarm commandlet
  $Farm = [Microsoft.SharePoint.Administration.SPFarm]::Local

  #Get All feature of the farm. Equallent to: Get-SPFeature commandlet
  $FarmFeatures= $Farm.FeatureDefinitions

  #Feature to Search
  $FeatureDisplayName = "IPFSWebFeatures" #Infopath Form Services Feature

  #Scan Farm Level Features
  $FarmLevelFeatures = $farm.FeatureDefinitions | Where-Object { ($_.Scope -eq "Farm") -and ($_.DisplayName -eq $FeatureDisplayName) }
  if($FarmLevelFeatures -ne $null)
  {
   "$($FeatureDisplayName) Installed at Farm Level!"
  }

   #Get all web applications and scan through 
   $WebApplications = Get-SPWebApplication "http://sharepoint.crescent.com"
   #To process all web applications, simply use: $WebApplications = Get-SPWebApplication 
   foreach($WebApp in $WebApplications)
   {
  Write-Host "Processing web Application : $($WebApp.url)"
  $WebAppLevelFeature = $webApp.Features |  Where-Object { $_.Definition.DisplayName -eq $FeatureDisplayName }
  #If Feature found
  if($WebAppLevelFeature -ne $null)
  {
  "$($FeatureDisplayName) Activated at Web Application $($webApp.URL)"
  }

  #Get All site collections of the Web Application  
  $SitesColl = $webApp.Sites  

  #Iterate through each site collection
  foreach($Site in $SitesColl)
  {
      #Write-host "Processing Site: $($Site.Url)"
   $SiteLevelFeature = $Site.Features |  Where-Object { $_.Definition.DisplayName -eq $FeatureDisplayName }
   #If Feature found
   if($SiteLevelFeature -ne $null)
     {
    "$($FeatureDisplayName) Activated at Site Collection $($Site.URL)"
     }

    #Enumerate each sub-site
    foreach($web in $site.AllWebs)
    {
         #Write-host "Processing Web: $($Web.Url)"
   $WebLevelFeature = $web.Features | Where-Object { $_.Definition.DisplayName -eq $FeatureDisplayName }
    #If Feature found
     if($WebLevelFeature -ne $null)
        {
      "$($FeatureDisplayName) Activated at Web Level $($web.URL)"
        }
     $web.Dispose()
  }
   $site.Dispose()
    }
 }

Add-PSSnapin "Microsoft.SharePoint.Powershell" -ErrorAction SilentlyContinue

$siteurl = "http://sharepoint.crescent.com"
$Site = Get-SPSite $siteURL

#send all features to output file features.txt
$site.WebApplication.Farm.FeatureDefinitions `
| where-object {$_.solutionid -ne '00000000-0000-0000-0000-000000000000'} `
| Sort-Object solutionid,displayname `
| ft -property displayname,scope -auto -groupBy solutionid > "d:\features.txt"

#replace solutionId in features.txt with solution name
foreach($solution in $site.WebApplication.Farm.Solutions)
{
    (Get-Content "d:\features.txt") `
    | Foreach-Object {$_ -replace $solution.solutionid.ToString(), $solution.Name} `
    | Set-Content "D:\features.txt"
}

$site.Dispose()

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

#Get-SPSite cmdlet for MOSS 2007
function global:Get-SPSite($url)
 {
    return new-Object Microsoft.SharePoint.SPSite($url)
 }

#Get-SPWeb cmdlet for MOSS 2007
Function global:Get-SPWeb($url)
{
  $site= New-Object Microsoft.SharePoint.SPSite($url)
        if($site -ne $null)
            {
               $web=$site.OpenWeb();

            }
    return $web
}

  #Parameters
  $web = Get-SPweb "http://sharepoint.crescent.com/regions/emea/se/"
  $ListName = "Employee of the Month"
  $FieldName = "Desciption"

  #Get the List 
  $list = $web.lists[$ListName]

  #Set the "Allow unlimited length in document libraries" option to true programmatically
  $list.Fields[$FieldName].UnlimitedLengthInDocumentLibrary= $false 

  #Update the Field
  $list.Fields[$FieldName].update()

    static void Main(string[] args)
        {
            SPSite mySite = new SPSite("http://sharepoint.crescent.com/regions/emea/se/");
            SPWeb myWeb = mySite.OpenWeb();

            SPList myList = myWeb.Lists["Employee of the Month"];
            SPField myField = myList.Fields["Description"];

            ((SPFieldMultiLineText)myField).UnlimitedLengthInDocumentLibrary = true;
            myField.Update();
        }

• OOTB column doesn't provide a way to enter more than 255 characters in Multiple Lines of Text field. As user already entered values in it and wants to make it allow more than 255 chars.
• When a SharePoint field's internal name needs to be changed.
• There is requirement to add a new column, whose values are partially based on an existing column

[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")

#Using Get-SPSite in MOSS 2007
function global:Get-SPSite($url)
 {
    return new-Object Microsoft.SharePoint.SPSite($url)
 }

Function global:Get-SPWeb($url)
{
  $site= New-Object Microsoft.SharePoint.SPSite($url)
        if($site -ne $null)
            {
               $web=$site.OpenWeb();

            }
    return $web
}

 #Parameters
 $web = Get-SPweb "http://sharepoint.crescent.com/"
 $listName = "Pictures"

 #Use the Display Names
 $CopyFromColumnName = "Description" #column copy source
 $CopyToColumnName = "Desc"  #destination column

  #Get the List
  $list = $web.lists[$ListName]

     #Get all Items  
     $Items = $list.Items

     foreach ($Item in $items)
        {
            #copy data from one column to another
            $item[$copyToColumnName] = $item[$copyFromColumnName]

            #Do a system update to avoid Version and to Keep same metadata
            $item.SystemUpdate($false)
        }