One of the most common patterns seen in ASP.NET MVC is dependency injection (otherwise known as Inversion of Control).  Why? It loosely couples the parts of the application and really emphasizes the ability to unit test the separate layers of your application.  Why is unit testing important? Unit Testing, while it may add more time to your development, it allows developers, testers and the client to feel more confident that their code is doing what it is supposed to do.

So what exactly is dependency injection?  Many of us use patterns without even knowing that we are doing it, so this may sound familiar.  It’s actually pretty straightforward, using an instance of one class, it calls an instance of another class, but not by a concrete implementation, but rather by interface.  In essence, dependency injection, aims to reduce the amount of boilerplate wiring and infrastructure code that you must write and implement one of the core design principles, code to an interface not a implementation.

Here’s a simple example, the AccountService has to get a Account.   It looks like this:

public class AccountService
{
  private IAccountRepository _accountRepository;
  public AccountService(IAccountRepository accountRepo)
  {
    _accountRepository = accountRepo;
  }

  public Account GetAccount(int accountId)
  {
    return _accountRepository.GetAccountById(accountId);
  }
}

When we need the AccountRepository, we ask the dependency container to get it for us the instance based on what it’s mapped too.  Why does this benefit developers? It’s good because the AccountService doesn’t know or care about it gets an Account.  You can stub out what the methods and properties on a fake IAccountRepository might return, and test just the AccountService.  You can also use this to change the implementation of the IAccountRepository on the fly based on the type of storage you may be using.  Coupled with a framework such as Ninject, using dependency injection is a powerful pattern that should be used more often.  In one of my following posts I’ll go into using an example of using Ninject and a basic tutorial.

Article source: http://robbiemadan.com/2012/05/09/patterns-and-practices-dependency-injection-101/

How does this work from an application perspective? Lets assume your building out a membership provider, when you first go to create the user you will store the password as a hash – so instead of storing ‘qwerty’ you will store “d8578edf8458ce06fbc5bb76a58c5ca4″. When that user logs in next, they will enter their password, the system will hash this password using the same algorithm and compare the hashed values, there is no way for you to compare the actual passwords without hashing them. This is quickly becoming standard practice.

Now what if I wanted to break into this account? The fact that the same input always generates the same hash tag means I can build up a database of inputs and outputs and use that to attack an account, this is called using a ‘rainbow table’, a database of inputs/outputs used to determine a hashed password.  Rainbow tables are easily found on the internet, so this one-way hash is not as safe as once thought.  If your interested in learning more about rainbow tables, check out http://ophcrack.sourceforge.net/.

So what’s the best way of stoping rainbow table hacking? Salting. By generating a random “salt” for every user and attaching it to their passwords before hashing, you have made the rainbow tables ineffective. For example, the password ‘qwerty123′ becomes ‘qwerty123AS@#$fgr=’ and is then hashed into ’8a7bb436d4849395072483f7715b7edb’.  Because the salt generates a random string and each user in your database has a different salt value, you have effectively removed the threat of rainbow tables.

If you want to read more about the inner workings of rainbow tables, take a look at this post: http://chargen.matasano.com/chargen/2007/9/7/enough-with-the-rainbow-tables-what-you-need-to-know-about-s.html

Article source: http://robbiemadan.com/2012/04/26/password-storage-101/

Background

I am just learning how to use TFS 2010 build services and ran into an issue setting up the default build.  The XAML templates just didn’t exist.  Being my first experience with TFS build I had no idea they were missing in the first place.  I realized fairly early on that something was not quite right with the team project.  I started going through blogs, MSDN, etc… trying to determine where I went wrong but could not find any information on how to create the templates or why they would be missing in the first place.

All the documentation referred to the BuildProcessTemplates folder in source control which was not created with our project.  The  team project was created with Visual Studio 2010 on a brand new TFS 2010 installation.

Steps I took

I created my own test project to try and recreate the issue.  When I created a new team project, the BuildProcessTemplates folder was created and populated with the XAML files.  This obviously confused me as the projects were built less than a week apart.

To solve one issue, I copied the BuildProcessTemplates folder into my existing projects and checked them into source control.  I was then able to create a default build in less than five minutes.  This did not answer why the folder was missing in the first place.

What Happened

I did determine why the original project did not have the Build Templates created but the newly created test project did.  When TFS was installed, the build services were not configured.  The build services were configured after the original project was created.  If build services are not configured, TFS will not create the default build templates.  In hindsight this make sense, if there are no build services why bother with creating build templates.

Conclusion

I learned a few things from this issue, the most important for me being that the default build templates are not specific to a project and can be used in any project to created the default build.

This was my first Blog posting and I hope that it helps some people just getting started with TFS 2010 builds.

Here are the changes:

• Enabled call-via-work – allowing Enterprise Voice enabled users to make and recieve calls using your Enterprise Voice (Lync ID) number only. Connect with other using a single identity.
• Added user controls for adjusting the sound/vibration for incoming notifications.
• Improved Lync status icon: know if you can receive IM messages.
• Enabled copy of IM text to the clipboard.
• Multiple bug fixes.

Grab it at the Market: https://market.android.com/details?id=com.microsoft.office.lync&hl=en

Original Source: The RSA Animate: ‘DRIVE – The Surprising Truth About What Motivates Us’

I first heard of the concept of Convex Leadership during a TEDTalk by R.A. Mashelkar, when he was speaking at TEDIndia in 2009. His talk discussed breakthrough designs for ultra low cost products being developed in India. Borrowing the concept, Gandhian engineering, from Tata Motors, his discussion expanded on the concept of frugality and challenging conventional wisdom in technological innovations, engineering and new product development. Getting more, from less, for more….. meaning Getting more service, from less resources, for more people. Amazing concept for the manufacturing and production world; especially for a world of depleting resources and a population that can’t afford luxurious overpriced designs.

Going back to the concept of convex leadership, the talk by Mashelkar brought up the idea of how leaders can transform the views and perceptions of those around them to focus and act as one; this type of leadership is needed to take advantage of concepts like Gandhian Engineering. Mashelkar further discusses how he came up with the concept:

“Principal Bhave took us out into the sun to demonstrate to us as to how to find the focal length of a convex lens. He had a piece of paper here, a convex lens here and he moved it up and down and there was a point when there was a sharp focus and a bright spot on the paper. He showed the distance between paper and the lens and said that this distance was the focal length. But then the paper started burning. For some reason, he then turned to me, and said, Mashelkar, if you focus your energies like this, you can burn anything in the world.”

If you think carefully about this story, it tells you about the new model for the society and for the nation. What is the experiment? You have the lens. And what does the lens do? It takes the parallel rays of the sun and then lets them converge. And what is the property of parallel lines? Parallel lines never meet. Parallel rays never meet but the lens actually makes them meet. The “convex lens” brings things together to focus and work together – leadership that brings people together.

Lets bring this back to the world of technology for a minute. Many frameworks and methodologies exist on leadership and project management, but when it comes down to leadership, it really comes down to basics – team leadership means focusing the team on obtaining a goal. As a company, the same concept can be applied – focusing the company on common goals; focusing everyones energy on obtaining the same strategic goals is key to obtaining success. Leaders that are able to display the attributes of convex leadership will be able to focus their teams of employees towards achieving the objectives laid out by the company; in some cases this may be in the form of helping employees obtain their own objectives (SMART goals from performance reviews) which thereby result in moving a step forward towards reaching the overall company objectives. In the end, the ability to lead people and converge the parallel lines that represent individual goals, is the true measure of a good leader.

The challenging part is finding those individuals that can lead by using a convex leadership style within a company; these leaders are the ones who understand the true motivators that get people to work in the morning; the difference between intrinsic and extrinsic motivators, Herzberg’s motivation-hygiene theory and are able to build the culture and team that have chemistry to work together.

So, the question I pose is, do you have a leader that is able to motivate and focus you? Or are you that leader?

Article source: http://www.robbiemadan.com/2012/01/04/the-art-of-leadership

The underlining issue for the disconnect is that Lync requires SRTP encryption by default which the Windows Live network does not support.

Assuming that your federation is working to the Windows Live network, we have to insure that the Lync users have Public A/V connectivity:

Set-CsExternalAccessPolicy Global -EnablePublicCloudAudioVideoAccess $true

The second step is to change the Lync encryption requirement fromt required to supported. The Lync client will still try to negotiate an encrypted session first, but if that fails it will allow the unencrypted session with the Windows Live network to take place:

Set-CsMediaConfiguration Global -EncryptionLevel SupportEncryption

You can also apply these commands to a specific policy that you have created. After these commands are entered on the server, wait a few minutes and then sign out and back in to the Lync client. You can verify that change has taken place by looking at the PC to PC AV Encryption in Lync (hold down CTRL and right click the tray icon and select “Configuration Information”. The setting should display “AV Encryption Supported”.

If the encryption level is not changed there will be an error logged on the Front-End server when an A/V call is trying to be established:

Start-Line: SIP/2.0 488 Not Acceptable Here
ms-client-diagnostics: 52017;reason="Encryption levels do not match"

The whole process was pretty simple to implement, however it was a good exercise that helped me better understand how LightSwitch separates concerns. It was this knowledge and understanding that helped me implement a solution for another email challenge.

The challenge I have is this; I want functionality that will let me send an email on demand, via a button on a screen, and I don’t want to code some fancy WCF service or custom extension to do the job.

Here is the thing – you can’t call server code from the client. It is in the server code that the email processing occurs. Why? Because the client and common projects are Silverlight based projects and I can’t add the necessary System.Net reference to those projects – otherwise I would have used the System.Net.Mail namespace directly from the client.

But hey, the Server project is a .Net 4 class library project, and I can add the System.Net reference to that project. That is why the actual email processing has to occur in the Server project. Following me so far?

So, here is what I did…

In the Solution Explorer of my LightSwitch project, I switched to File View so that I can get at the Server project…

Knowing that I need to use an external (SMTP) email service to actually send out the email, I decided to store some static information that my email processing can use to process the email; such as stuff for the email service authentication. To do this, I opened the Server project settings.

Next, I added some Application scoped configuration settings…

…come on, you didn’t actually think that I would post my own credentials did ya…I learned from that mistake already

I made sure to save the updates.

Next, a folder is created within the Server project, and named the folder “UserCode”. Within that folder I created a new Class file and named it “EmailHelper.vb”.

This is the code I added to this file…

Imports System.Net
Imports System.Net.Mail

Namespace LightSwitchApplication
    Public Class MailHelper

        Private Property SMTPServer As String = My.Settings.SMTPServer
        Private Property SMTPUserId As String = My.Settings.SMTPUserID
        Private Property SMTPPassword As String = My.Settings.SMTPPassword
        Private Property SMTPPort As Integer = My.Settings.SMTPPort

        Private Property MailFrom As String
        Private Property MailFromName As String
        Private Property MailTo As String
        Private Property MailToName As String
        Private Property MailSubject As String
        Private Property MailBody As String

        Sub New(ByVal SendFrom As String,
                ByVal SendFromName As String, _
                ByVal SendTo As String, _
                ByVal SendToName As String, _
                ByVal Subject As String, _
                ByVal Body As String)
            _MailFrom = SendFrom
            _MailFromName = SendFromName
            _MailTo = SendTo
            _MailToName = SendToName
            _MailSubject = Subject
            _MailBody = Body
        End Sub

        Public Sub SendMail()

            Dim SMTPUserAddress = New MailAddress(_SMTPUserId)

            Dim mail As New MailMessage
            Dim mailFrom As New Mail.MailAddress(_MailFrom, _MailFromName)
            Dim mailTo As New Mail.MailAddress(_MailTo, _MailToName)

            With mail
                .From = mailFrom
                .To.Add(mailTo)
                .Subject = _MailSubject
                .Body = _MailBody
            End With

            Dim smtp As New SmtpClient(_SMTPServer, _SMTPPort)
            smtp.EnableSsl = True

            smtp.Credentials = New NetworkCredential(SMTPUserAddress.Address, _SMTPPassword)
            smtp.Send(mail)
        End Sub

    End Class
End Namespace

So, this class contains some pretty simple code. Instantiating the class requires a bunch of parameters that are later used by the SendMail() method. The SendMail() methid is where the mail message gets created, configured, and sent using the a SmtpClient. As you can see, some class properties are defaulted to the values that are stored in the App.Config file of the Server project (which were added earlier).

Next, I go back into the logical view of the solution.

In the logical view, a new table is created. The table name is “ProxyEmail”, and it looks like this…

Now, with this table, I have essentially created a “Model” that I can use in my workaround. Remember, my challenge is to do all this with native LightSwitch features and functionality. I don’t want to create a fancy-smancy WCF service or custom extension for this. I just want to get the job done. By creating this entity, I have, in essence, created a business object that I am going to use to do what I want to do.

Here is the fun part! I can’t call the Server code directly from any screens, however I know that my “entity” can access the server code via its dependencies. For example, my ProxyEmail entity has a method called ProxyEmails_Inserted(), which runs on the server when an entity as added to the table (add to the collection of ProxyEmail entities).

So, I add some code to this method…

…and here is the code if you want…

 Private Sub ProxyEmails_Inserted(entity As ProxyEmail)
            ' Write your code here.
            Dim sSubject = "Test Email."
            Dim carRtn = Environment.NewLine  Environment.NewLine

            Dim sMessage = "The following email has come from a button on LightSwitch..."  carRtn
            sMessage += "Testing 1, 2, 3!!"

            ' Create the MailHelper class created in the Server project.
            Dim mailHelper As New MailHelper(entity.SenderEmailAddress, _
                                             entity.RecipientName, _
                                             entity.RecipientEmailAddress, _
                                             entity.RecipientName, _
                                             sSubject, _
                                             sMessage)

            ' Let 'er rip!
            mailHelper.SendMail()
        End Sub

So, this is pretty much the same as the last post. Right, but here is how this similar stuff is used to create a feature that will allow you to send an email on demand, rather than relying only on updates to entities.

I create a new Screen and, using the New Data Screen template, name it “SendAnEmail”, but don’t assign any screen data to it…

In the screen designer for the new SendAnEmail screen, I click Add Data Item… and create a Method with a name of “SendMyEmailOnDemand”…

Back in the screen designer, I expand the Screen Command Bar, and drag and drop the SendMyEmailOnCommand method to the command bar.

I right click the newly added button, and select to Edit Execute Code.

I edit the method to this…

…and here is the actual code you can use…

        Private Sub SendEmailOnCommand_Execute()
            Dim newEmail = DataWorkspace.ApplicationData.ProxyEmails.AddNew()
            With newEmail
                .RecipientEmailAddress = "paulspatterson@hotmail.com"
                .RecipientName = "Paul Patterson"
                .SenderEmailAddress = "paul@selectsystems.ca"
                .SenderName = "Paul Patterson (Select Systems)"
            End With

            DataWorkspace.ApplicationData.SaveChanges()
            newEmail.Delete()
            DataWorkspace.ApplicationData.SaveChanges()
        End Sub

What this is doing is simply creating a new ProxyEmail entity, settings it’s properties, the committing the insert to the system. The SaveChanges after the setting the properties will cause the ProxyEmails collection to fire that ProxyEmails_Inserted() method that was wired up earlier, which then sends the email from the server code. After that, the newly added entity is deleted because I don’t need it any more.

So, I F5 to test it…

… and I click the Send Email On Demand button. Then I go and check my email, and presto…

Yes!

This may not be the super cool software code monkey way of doing things, but who cares! It does the job, and I did in no time at all.

Hope you find it useful!

Cheers

Article source: http://www.paulspatterson.com/technology/lightswitch/microsoft-lightswitch-sending-emails-from-the-client/

Employees periodic assessment is an important and tedious repetitive process for the HR department. As a leader in Software Development, Quercus Solutions decided to computerise its employees assessment process. I was charged with implementing a simple, affordable, and extensible solution using a non code InfoPath Form and a declarative SharePoint Designer 2010 Workflow.

Process Description and Security Constraints

Quercus Employees assessment process involves four parties, the employee himself, his coach, the HR department, and the company manager. One big concern is to keep the assessment data completely private and secure.

The assessment  process consists of multiple stages.  The following flowchart shows these stages.

Assessment Process

To start an assessment, the HR manager should create a new assessment Form. He/she, then, fills a view of the  form that includes some basic parameters such as: employee name, coach name, etc. We plan, in a future release,  to automate this step using a SharePoint employees External List and a Timer Job. When a Form is created, no body Should be given access to it, except the HR Manager.

The second stage starts when the HR manager decides that the process of assessment is ready to go. At this moment an alert is sent  to the coach. It should give him a link to the assessment Form that he should fill. As a part of filling the assessment form, he should decide about a meeting date with the employee to discuss the assessment.

At this second stage,  the coach should be the only person that have write access to the Form. The HR and the company manager should only have read access. Neither the employee himself, nor any other person should be able to access the Form at all.

The third stage starts when the coach signals that he is finished with the assessment. The coach can edit and modify the assessment as many times as he wishes, however, he can’t modify it once he marks it as ready for the next stage.  An alert is, then, sent to the employee to ask him to revise the assessment and to inform him of the meeting date.  The body of the alert should include a link to the assessment Form. The employee should  be able to navigate to the Form and read his coach assessment. He can enter his comments and specify his future goals for the next period.

While doing so, the employee should not have any write access to the part of the Form containing his coach assessment. However, he should have write access to the part of the Form including his comments and his goals. Any other involved party, even the coach, should have, only, read access to the Form. You may wonder why we don’t permit the coach to modify his assessment? This is because we don’t want him to change the Form while the employee is viewing it. Any other person except those involved in the process should not be capable of accessing the Form by any means. In particular, he or she must not have the permission to download the form to his/here computer and open it with an XML editor

The fourth and final stage starts after the employee completes his review. In this stage the coach and the employee meet  together  to discuss the assessment. The coach should be able to change his assessment in case he have new evidence resulting from the meeting. He, also,  should  be able to terminate the assessment process. No other party could be able to modify the Form. Non involved parties, should not, even, be able to access the Form.

Once the coach marks the assessment as completed, no other person except the HR manager and the company manager could  be able to access the Form. This is true even for the coach and the employee.

Outlines of the Solution

The solution is based upon a non code InfoPath Form published to a SharePoint InfoPath Form Library. The Form is accessed with InfoPath  client filler; i.e., the form is not web enabled. The design justification of this choice is the  need to use InfoPath User Rules combined with InfoPath  Views to control access to the different parts of the form. As User Rules are not supported in InfoPath web Forms, we  excluded it in the first implementation. The other rational is that all Quercus employees have InfoPath filler installed on their computer. At the end of this article I will devote a section on how to use InfoPath Web Forms instead of InfoPath filler.

The solution uses also a declarative workflow developed with SharePoint Designer 2010 to alert the involved parties and control the  process flow. It also sets SharePoint items permissions on the Form Library using a workflow Impersonation Step.

In Part 2 of this article I will explain the implementation in details.

About the Survey

 The survey covers 650 individual members of the AIIM community between January 28,2011, and February 14, 2011. Survey Participants represent organizations of all sizes. Larger organizations over 5,000 employees represent 35%, with mid-sized organizations of 500 to 5,000 employees at 41%. Small-to-mid sized organizations with 10 to 500 employees constitute 24%. Organizations of less than 10 employees (26) are not included in the report.

 The findings concerning SharePoint are classified in three headings; Adoption, Maturity and Governance, and Strategies.

 Adoption

• 58% of respondents are already using SharePoint, rising to 70% of the largest organizations.
• SharePoint 2010 version has attracted 13% of respondents as first time SharePoint users
• Only 20%  have no interest in SharePoint.
  

Maturity and Governance

•   27% admit that valuable content is being stored in SharePoint across the organization but there is no real guidance on what/how to store .
•   18% have stable and well-governed systems.
•   only 5% of users would consider their SharePoint implementation to be fully optimized and integrated with other applications and repositories.

Strategies

• 11% of respondents have SharePoint as first document or content management suite.
• 49% are planning to integrate SharePoint with their existing – or new – ECM or records management suites.
• 24%  have not yet formulated any plans to integrate SharePoint with their existing ECM/DM/RM systems
• 4% are phasing out existing systems in favour of SharePoint

For a full version of the report go to http://www.aiim.org/