Setting the lock state for a site collection has a few rules that aren't entirely clear. You can set the lock state via PowerShell using the Set-SPOSite command:

Set-SPOSite https://[tenant].sharepoint.com/sites/targetsite -LockState [NoAccess|Unlock]

You can read more about that on the TechNet article for it here: https://technet.microsoft.com/en-us/library/cc263238(v=office.15).aspx

Rules

The site must not be one of the following:

• Tenant admin site (duh! obvious)
• Root site collection (https://[tenant].sharepoint.com)
• Search site collection (https://[tenant].sharepoint.com/search, or whatever yours is)
• Public site (https://[tenant]-public.sharepoint.com)

CSOM Approach

using (var clientContext = new ClientContext(tenantUrl)) {
    clientContext.Credentials = spoCredentials;
    var tenant = new Tenant(clientContext);
    var siteProperties = tenant.GetSitePropertiesByUrl(siteUrl, true);
    clientContext.Load(siteProperties);
    clientContext.ExecuteQuery();

    Console.WriteLine("LockState: {0}", siteProperties.LockState);

    siteProperties.LockState = "Unlock";
    siteProperties.Update();
    clientContext.ExecuteQuery();
}

This will will also be a future OfficeDevPnP.Core extension (in the dev branch, now). The method is TenantExtensions.SetSiteLockState(this Tenant tenant, string siteUrl, SiteLockState lockState).

When the site is locked, you'll see it in the admin site with a lock icon next to it as seen below.

First, you'll need to navigate to the Office 365 Admin Settings from the Settings gear. This will take you to the Admin dashboard where you'll find a link in the top right corner.

This will take you to the Tenant customization settings page. Choose Custom Theming in the left navigation to get to the Manage Custom Themes view:

You can modify the following settings from here:

• URL the suite bar navigates the user
• Color of the suite bar
• Color of the text links that appear to the right (this includes icons for notifications)
• You can select from one of the selected colors to set as the Office 365 logo. Note, the words powered by and the logo for Office 365 are still displayed here.

Cheers!

Unit testing the Office Developer Patterns & Practices Core solution was definitely a challenge for us. Since it was grown from community code samples, most of the testing was done by refactoring similar code so it worked across many samples. The problem is that the Core component has become more and more reliable and the method signatures are not tested unless we run individual tests.

Fakes vs. Real Tenant

Mock objects, or Fakes as they're called in VS, are a great solution for unit testing. They allow us the ability to act as both the server and the client to abstract our tests from SharePoint. However, given that there isn't a fakes framework already developed for SharePoint, it's very difficult to implement all the scaffolding for SharePoint CSOM and be able to ensure that objects are properly initialized as expected. This led us to believe that the effort of building such a thing is less valued than testing the Core solution against a developer tenant.

Console Application?

The console application is the old faithful. Anyone can write a Console app to unit test code and write out all their assertions and exceptions. This tried and true method has been a great solution for C++ developers; however, given the number of options out there, this was obviously not feasible. We wanted build integration via TFS and we wanted the community to be able to easily extend the app, which wouldn't happen this way. Ironically, when quickly testing a change to the API I was actually testing via console app in an ignored path…do what you have to, you know?

Client ID/Secret?

Using OAuth to test against the developer tenant is a great approach and would definitely validate a connection and that your code functions. Given that the Core assembly assumes that what is being passed in is a valid ClientContext object and almost all methods use a server object, the assumption is that authorization has already been established. The complexity of configuring the app with a client id/secret with the SP server during testing, it doesn't exactly seem the right approach when the wish is to test that all unit tests are valid for tenant-level permissions.

Ah, SharePointOnlineCredentials!

In the end, the right solution for this was decided to be to use SharePointOnlineCredentials to initialize the ClientContext object. This means that we can supply an app.config file that has dev site and tenant URLs to properly along with username and password. To initialize a ClientContext, one can simply use the format:

var spCredentials = new SharePointOnlineCredentials(username, password);
using (var clientContext = new ClientContext(devSiteUrl)){
    clientContext.Credentials = spCredentials;
    // perform CSOM operations
}

Put My Password in App.Config?

Obviously, it's not a good practice to put your username/password in the App.config file, especially since this is shared code that is community driven and you don't want it to accidentally get pushed to your fork. So, we simply added the App.config file to .gitignore to leave it out leaving that responsibility to you. The App.config.sample file in the new OfficeDevPnP.Core.Tests project which can be copied in your local solution, renamed to app.config, filled in, and you can unit test. Check it out in the dev branch.

Cheers!

Mail apps for Office are an integration of what we are already chained to and the capability to empower email to be more insightful. They can give an old application a new interface to grow.

Office AMS 2.0

In the recent release of Office AMS 2.0, we added a simple mail app for picking up YouTube video urls from an email and present them in the Outlook interface in both the web and desktop clients. It is located in the [OfficeAMS]\Samples\Core.MailApps folder.

Office Mail Apps AppManifest.xml

Visual Studio will structure your application into 2 parts: the Office application manifests and the web applications that support them. You can have multiple Mail App manifests in one Office App project, but for the purpose of this release, only one is included.

When you double-click the app Core.YouTubeApp, you will be presented with the deployment properties interface. It has tabs for:

• General – Details about the app
• Read Form – What scenarios cause the app to become available when the reading pane is visible
• Compose Form – What scenarios cause the app to become available when the compose pane is visible
• App Domains – What site URLs are available to be opened from your app when making cross-domain calls

The AppManifest.xml file describes the app to the Office client application. You can modify the same features available in the tabbed experience in XML directly. The XML for the YouTube app is as follows:

<OfficeApp xmlns="https://schemas.microsoft.com/office/appforoffice/1.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:type="MailApp">

  <Id>e1c173ce-6df8-479e-86c1-59fa33774441</Id>

  <Version>1.0.0.0</Version>

  <ProviderName>Contoso</ProviderName>

  <DefaultLocale>en-US</DefaultLocale>

  <DisplayName DefaultValue="YouTube" />

  <Description DefaultValue="YouTube video player"/>

  <Capabilities>

    <Capability Name="Mailbox" />

  </Capabilities>

  <DesktopSettings>

    <SourceLocation DefaultValue="~remoteAppUrl/AppRead/YouTube/YouTube.html" />

    <RequestedHeight>350</RequestedHeight>

  </DesktopSettings>

  <Permissions>ReadItem</Permissions>

  <Rule xsi:type="RuleCollection" Mode="Or">

    <Rule xsi:type="ItemIs" ItemType="Message"/>

    <Rule xsi:type="ItemHasKnownEntity" EntityType="Url" IgnoreCase="true" FilterName="YouTubeVideos" RegExFilter="youtube\.com\/watch" />

  </Rule>

  <DisableEntityHighlighting>false</DisableEntityHighlighting>

</OfficeApp>

General Tab

The general tab has basic settings for your app. You can set the Display Name (which appears on the apps tab in the Reading Pane), set the version, list the provider, provide a description and icon, and you can set permissions. You can see it in the image below.

In the Office AMS sample, we’re only going to be reading the email and not modifying the email or modifying the user’s mailbox in any manner. Read more about permissions here.

Read Form Tab

The Read Form tab specifies what items cause the app to be activated. It allows you to create rules based on regular expressions which may or may not already exist. Any or All of the scenarios must match (depending on the top-level rule) in order for the app to be activated. The Office API will automatically detect all URLs, email addresses, phone numbers and some other items, but you can further filter these with your own regular expressions.

In the YouTube scenario, we’re looking for the presence of a youtube.com/watch address. If this regular expression matches in the message or subject, the app will appear in the Reading Pane in Outlook or Outlook Web Access. Note that the Filter name has been set. This enables us to find the items by name during runtime.

The Source Location points to the web address your app will point to once the app is activated.

The only drawbacks with the filters, right now, manifest themselves when using the Item is appointment filter. If you are trying to use the location as a filter (maybe trying to find a PIN code for teleconference calls, you may have issues. Forwarded meeting invites do not appear as appointments, they are considered a “message”, so you may not see your app activated with just “appointment”. It’s worth experimenting with, though.

The Web Application

The YouTube application is very simple. The web site hosts a basic HTML page with no server-side code. We could easily implement server-side code here to perform operations such as OAuth authorizations, dynamic views of content, or event write a data entry application; however, in this simple example we will find all of the YouTube entries in the email message and put them into a nice viewing window in Outlook.

The web application has a folder already configured with an AppRead folder for the Read Form view. There is nothing special with the name, just ensure that the name matches what is in the AppManifest when it is published and consumed by your Outlook client in the Source Location attribute (currently ~remoteAppUrl/AppRead/YouTube/YouTube.html):

Script Me Some YouTube Videos!

The YouTube.js script is very simple.

1. Get the item from the Office.context.mailbox.item object hierarchy.
2. Call item.getFilteredEntitiesByName("YouTubeVideos") which will provide all the entities that are picked up by the interface. In the sample, I wrote the code to point to the item.getEntities() because there is a separate regular expression filter on the URL, anyways. The separate regular expression is to find the ID of the YouTube video for use in the youtube.com/embed url which is used to display the video.
3. Provide the video ID to individual tabs for use when the tab is clicked.
4. Upon click, set the event to replace the contents of the video frame with the embedded player path for YouTube and provide a link to the video.

Deployment

The deployment is a very simple process as well.

1. Deploy the app to a web host. This could be your own web host running on an Apache server or Windows server. Or, Windows Azure can be your web host (remember that you get 10 web sites for free).
2. Find a location to host the AppManifest.xml file. Upon building the project, I copy the Core.YouTubeApp.xml to a folder within the web site called Apps and set the ~remoteAppUrl to whatever the actual site URL is. This is actually done by a file called UpdateAppUrl.ps1 stored in the Core.MailApps directory and is run from the Mail App project. You can update the UpdateAppUrl.ps1 file with your actual domain address.
3. If your administrator allows it, from within the Outlook Web Access site you can add the app directly as a trusted app by pointing directly to the appmanifest URL.
4. You can also submit this app as an Office store app.

There you have it, a simple YouTube app. Now, I want to see one in the store and one for Channel 9.

It doesn't.

How do I get the language packs?

To get the language packs, go to the respective language pack page:

• SharePoint Foundation 2010 Language Pack
• Language Pack for SharePoint Server 2010, Project Server 2010, Office Web Apps 2010 bundle (note that this includes SharePoint Foundation 2010)

After reaching this page, change the dropdown that says Change Language from English (or your browser default language) to the language that you want and it will navigate you to the other language page so you can download the language pack for your target language. You will simply click the download button (it will be translated into the target language).

The files from all the language packs are named SharePointLanguagePack.exe (Foundation) and ServerLanguagePack.exe (Server), so I would suggest that you rename the file to include the language global name (e.g. ServerLanguagePack_de-de.exe).

How do I get Service Packs?

Language Packs do have service packs. Unfortunately, there is a glitch with the naming in Microsoft Download in which the title of the SharePoint Server language pack is improperly named. The process for selecting the language is the same as before, but each file is named with both the KB article identifier as well as the language that it is updating (e.g. serverlanguagepack2010sp1-kb2460056-x64-fullfile-de-de.exe).

The locations for SharePoint language pack service pack 1 downloads are:

• Service Pack 1 for SharePoint Foundation 2010 Language Pack (KB2460059)
• Service Pack 1 for Server Language Pack 2010 (KB2460056) (note that this is the SharePoint Server language pack update which includes the SharePoint Foundation 2010 Language Pack update)

If you have to install a lot of language packs, it is easier to download, extract and slipstream them all in advance, then run through each install and finally finish it all with a SharePoint Configuration Wizard PSConfigUI.exe (or you can use psconfig.exe -cmd upgrade -inplace v2v).

To slipstream the installs you'll need to extract the core language file:

ServerLanguagePack_de-de.exe /extract:<extract-location>

Then you'll need to extract the update to the language Updates folder:

serverlanguagepack2010sp1-kb2460056-x64-fullfile-de-de.exe
 /extract:<extract-location>\Updates

When you run the base install of the language pack, it will install the language with all updates in place.

What about Cumulative Updates (CUs)?

Cumulative Updates are different from service packs because they contain all the language pack updates in the entire package. Note that instead of the CUs being created with a language noted in the file name (i.e. EN, DE, FR), they have the letters GLB for GLoBal in the file name. This means that when you update your servers, your language packs will get upgraded as well.

Enjoy!

The workaround is explained here:

https://blogs.msdn.com/b/heaths/archive/2006/02/01/64-bit-managed-custom-actions-with-visual-studio.aspx

https://blogs.msdn.com/b/noahc/archive/2007/06/29/string-equals-performance-comparison.aspx

This article has more detail on do's and don'ts for stringcomparisons:

https://msdn.microsoft.com/en-us/library/ms973919.aspx

Initialization method Contoso.Test.BreakingNewsTest threw exception.
System.IO.FileNotFoundException: System.IO.FileNotFoundException:
The Web application at https://intranet.contoso.com/ could not be found. Verify that you have typed the URL correctly. If the URL should be serving existing content, the system administrator may need to add a new request URL mapping to the intended application.

I finally asked a colleague of mine (Jeremy Jameson) how he resolved it. Thankfully, he's already created an excellent post on it here: https://blogs.msdn.com/jjameson/archive/2009/10/08/web-application-at-could-not-be-found-error-on-moss-2007-x64.aspx

Additionally, my hobby as a photographer has taken over more of my life than coding for fun. I enjoy it more than deciphering the latest Silverlight release, fiddling with SharePoint 2010 or tinkering with ASP.NET 4. I can't do it all, I guess...

My commitment is to begin writing again, although, I'm not committing myself to more than 12 entries this year (or one per month). With the betas of SharePoint 2010 and eventual release, I'm sure I'll have some ideas to blog more frequently.

Cheers and welcome 2010!