I’m happy to announce that I’ll be speaking at the SharePoint Conference in March. My session is Deep Dive: REST and CSOM Comparison, which fits in nicely with the Pluralsight course I made that just went live (and it’s successive parts coming in Q1).
Details available here: http://www.sharepointconference.com/content/sessions/SPC423
I’ll post more information here as the conference gets closer. See you in Vegas!
This is actually the first of three parts to the course, with the next two parts coming in Q1 2014. Here’s the table of contents for part 1:
- Fiddler and an Introduction to REST
- Reading SharePoint Data with REST APIs
- Creating, Updating and Deleting SharePoint Data with REST APIs
- Final Thoughts for Part 1
I’m obviously a bit biased, but I think there’s a LOT of good material in here – including some that I don’t think you can find anywhere else, or that other published content is just plain wrong or incomplete. It intentionally starts out very basic but then quickly moves into the deep end of the pool, covering both REST and JSOM. There are also modules on the best/proper ways to work with libraries (both deploying to SharePoint and downloading to the user’s browser) and finishes with a discussion on the REST vs. CSOM debate and which one you should use.
Stay tuned for more highlights on the content. If you don’t have a Pluralsight subscription, you can get one for $29/month, or wait for the companion e-Book (more on that later!)
*: I say “real” because there is a course I recorded for Critical Path Training originally that was converted to a PS course but I don’t really count that one
A few months ago my primary client asked me to take over a project that had been developed in-house. I’ve spent some time since then getting acclimated to the project, fixing some high-priority bugs and am now beginning to look at truly taking ownership of the codebase. As part of that I’m looking at trying out some new tools to help. Thanks to the folks at Telerik for giving me a copy of their tools (JustCode, JustTrace, JustDecompile, and JustMock) to kick the tires on. I’m also using Visual Studio 2013. To a certain extent, using a whole new toolset (I have previously used DevExpress’ CodeRush, which I still love but I wanted to try something new to see if there’s something better) is going to slow things down, but the client is OK with that and I’m looking forward to it. Things may get a little confusing as I try to figure out whether something new is VS2013 or Telerik, but I’ll do my best to keep them straight.
To make things even more interesting, the code is ALL VB.NET, which I haven’t coded in for…well…I’ve never coded VB.NET. I’ve done VB6 and its predecessors but never VB.NET. I think that’s the part that’s giving me more grief at the moment. Reading VB.NET is easy, but the muscle memory in my fingers is way too used to typing C#. Someone should just create a VS plugin that automatically deletes the semicolons from the end of your lines if you’re in VB.
One last point to make…this is also NOT a SharePoint project. It’s a straight .NET/SQL Server web application which is kinda cool and I’m looking forward to really flexing my (somewhat rusty) “regular” programming muscles a bit.
To give you an idea of what I’m up against, I snapped this little screenshot before I started:
Yikes! Nearly 1500 problems to take care of. Some of it is stupid like not following naming conventions, but some of it is serious:
- No separation of layers – data, business and UI code all freely intermingled
- No/minimal object use
- No stored procs – SQL statements directly in the code
- Hundreds (if not thousands) of lines of repeated code (copy/paste programming at its best)
- No unit tests
- Some of the code I can’t even run if I’m not on the client’s network to get access to resources
- Easily 15% of the total lines of code is commented out old code that is no longer used
I’ll be posting articles over the next few months as I whip this codebase into shape. Some of it will be tool-related as I test out Telerik and VS2013, some of it will be rants and some of it will be about the code itself.
I came across something interesting today that I’m still mulling over; I haven’t gotten comfortable with this yet and so don’t really know how I feel about it and its implications. What I’m talking about is a property on SPList called AllowEveryoneViewItems. MSDN has the following to say about this property:
Gets or sets a Boolean value specifying whether everyone can view documents in the document library or attachments to items in the list. The AllowEveryoneViewItems property does not apply to all list items, but only to documents in document libraries or to attachments in list items. This property only works when users browse directly to a file through the browser, and it has no effect on the rest of the user interface or the object model.
The net effect of setting this property (either declaratively in your ListTemplate Elements file, via PowerShell or programmatically) is that you can make files in a document library or attachments on list items available (read-only) to all users, almost completely bypassing SharePoint security. I say almost because it does not, in my testing, enable anonymous access to the files. But if the users have any access to your site, they have access to all files in any list with this property set to true. If you turn on anonymous access for the site, then everyone has read access to these files
What do you think? Is this good or bad?
I’ve given this presentation a few times and it usually goes over pretty well. It’s a rundown of core workflow information for SharePoint 2013 that should be of interest to IT Pros. While there isn’t any code in this one, developers should probably take a look as well.
Most recently, I was out in Indianapolis presenting at SPIN and so I updated the material a bit. Mostly this meant reviewing Spence’s articles on the matter and updating my content as necessary. I was happy to see that there were only 1 or 2 things I needed to change. The latest and greatest PDF of my presentation is available here.
Thanks to Rob Bogue for inviting me out to speak.
You’ll thank me next time you need to figure out what users have done so you can replicate it in a controllable/deployable manner. J
- Business is good and continuing to trend in the right direction (up, if you’re wondering).
- Life is busy.
- There are only 24 hours in a day.
Combine all three of these together and I very quickly come to the realization that it’s time to find some help, so I’m looking to hire a personal/administrative assistant. Here’s some information on the position, in no particular order:
- Local to the Chester County, Pennsylvania area – there is need for a local person for some tasks
- Approximately 10-15 hours per week – some weeks more, if you’re available, some weeks perhaps less, but probably not. Other than a minimum of 2-3 hours that MUST be done each week, the task list can be managed to fit your availability on a week by week basis.
- 100% flexibility on the hours. Except for the occasional need to meet in-person and the fact that some of the things (errands, etc) must be done while stores/shops are open, I don’t care when you work. 4 AM or 4 PM – it makes no difference to me
- Remote work – My office is in my house and it’s barely big enough for me, so everything can be done from your home, a coffee shop, etc. Again, it doesn’t matter to me.
Type of work:
- Scanning and electronic filing
- Research on various topics
- Scheduling and calendar maintenance
- Data entry
- Lightweight software/website testing
- Errands (local pick-up/drop-off)
- More (TBD)
- Pay rate is TBD. I’m looking to pay fairly and so am open to a discussion of what that means
- The person selected will be a 1099 contractor, not an employee of my business
Please contact me if you are interested (contact information is available on my website: www.mannsoftware.com).
I’ve only tested the remove operation, but I’m assuming the get operation operates the same way.
In my testing, the loginName parameter must be the full claim name, for example (i:0#.w|wingtipmdebakey) instead of the friendlier WingtipMDebakey. This severely limits the usefulness of these functions because, unless you are going to hard code the claim token and provider information (the i:0#.w| part) and then tack the user-friendly login name on the end, which is probably a bad idea as it restricts your code from working across different claim types or providers, you’re going to have to get the user object first and get the login name from there (via user.get_loginName), at which point, you might as well just use the remove method on the UserCollection object.
In other words, instead of this:
var user = web.ensureUser(“Wingtip\MDebakey”);
Just do this:
var user = web.ensureUser("Wingtip\MDebakey");
This is quite obvious when you think about it, but it’s easy to miss nonetheless when you’re searching for something in a hurry and could lead to some problems:
It’s easy to tell which version you’re in, it’s right at the top:
With the server-side OM, a lot of times it didn’t matter which version you referenced because, unless you were looking for something about a new capability, the server-side OM was pretty well established and the core bits didn’t change very much.
This is not so with the JS OM. It is very much still evolving and even core bits are seeing massive changes. One case in point, the Web class had 14 methods in SharePoint 2010 but that count more than doubles in 2013 to 30 methods.
If you’re looking at the wrong page in MSDN, you’re going to miss a lot of interesting capabilities.