Add Strategies for ArrangeInterview

src/StrategyPattern/ArrangeInterview/ArrangeInterviewMotivationalExample.cs

@@ -158,7 +158,7 @@ namespace StrategyPattern.ArrangeInterview
                     Console.WriteLine("Reserve a meeting with any medium/senior developer");
                     break;
                 case Experience.Medium:
-                    Console.WriteLine("Prepare medium tester interview questions");
+                    Console.WriteLine("Prepare medium developer interview questions");
                     Console.WriteLine("Give him a small program to develop before he comes here");
                     Console.WriteLine("Reserve a meeting with any senior developer");
                     break;

src/StrategyPattern/ArrangeInterview/Strategy/ArrangeInterviewExample.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class ArrangeInterviewExample
+    {
+        public static void Run(InterviewedPerson[] persons)
+        {
+            InterviewManager interviewManager = new InterviewManager();
+            Console.WriteLine("Arranging interview for {0} perons", persons.Length);
+            foreach (var person in persons)
+            {
+                Console.WriteLine();
+                Console.WriteLine("Arranging interview for {0}-{1}-{2}-{3}", person.Name, person.Role, person.Experience, person.HiringType);
+
+                IInterviewStrategy strategy = interviewManager.GetInterviewStrategy(person);
+
+                strategy.Arrange(person);
+            }
+        }
+    }
+
+    public class InterviewManager
+    {
+        public IInterviewStrategy GetInterviewStrategy(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with one from HR");
+            switch (person.Role)
+            {
+                case Role.Devloper:
+                    return GetDeveloperStrategy(person);                    
+                case Role.Designer:
+                    return GetStrategyFOrDesigner(person);                    
+                case Role.Tester:
+                    return GetStrategyForTester(person);                    
+                case Role.Manager:
+                    return GetStrategyForManager(person);
+                case Role.DevOp:
+                    return GetStrategyForDevOp(person);
+                default:
+                    throw new NotImplementedException("not implemented how to arrange interview for:" + person.Role);
+            }
+        }
+
+        private IInterviewStrategy GetStrategyForDevOp(InterviewedPerson person)
+        {
+            //It could get more complex, if we decide we want different process for different positions(part time/full time)
+            switch (person.Experience)
+            {
+                case Experience.Junior:
+                    return new JuniorDevOpStrategy();
+                case Experience.Medium:
+                    return new MediumDevOpStrategy();
+                case Experience.Senior:
+                    return new SeniorDevOpStrategy();
+                case Experience.RockStar:
+                    return new RockstarDevOpStrategy();
+                default:
+                    throw new NotImplementedException("hiring for " + person.Experience + " is not implemented");
+            }
+        }
+
+        private IInterviewStrategy GetStrategyForManager(InterviewedPerson person)
+        {
+            switch (person.Experience)
+            {
+                case Experience.Junior:
+                    return new JuniorManagerStrategy();
+                case Experience.Medium:
+                    if (person.HiringType == HiringType.FullTime)
+                        return new MediumFullTimeManagerStrategy();
+                    else
+                        return new MediumNonFullTimeManagerStrategy();
+                case Experience.Senior:
+                case Experience.RockStar:
+                    return new SeniorAndRockstarManagerStrategy();
+                default:
+                    throw new NotImplementedException("What kind of experience is this?");
+            }
+        }
+
+        private IInterviewStrategy GetStrategyForTester(InterviewedPerson person)
+        {
+            //It could get more complex, if we decide we want different process for different positions(part time/full time)
+            switch (person.Experience)
+            {
+                case Experience.Junior:
+                    return new JuniorTesterStrategy();
+                case Experience.Medium:
+                    return new MediumTesterStrategy();
+                case Experience.Senior:
+                    return new SeniorTestingStrategy();
+                case Experience.RockStar:
+                    return new RockstarTestingStrategy();
+                default:
+                    throw new NotImplementedException("hiring for " + person.Experience + " is not implemented");
+            }
+        }
+
+        private IInterviewStrategy GetStrategyFOrDesigner(InterviewedPerson person)
+        {
+            //It could get more complex, if we decide we want different process for different positions(part time/full time)
+            switch (person.Experience)
+            {
+                case Experience.Junior:
+                    return new JuniorDesignerStrategy();
+                case Experience.Medium:
+                    return new MediumDesignerStrategy();
+                case Experience.Senior:
+                    return new SeniorDesignerStrategy();
+                case Experience.RockStar:
+                    return new RockstarDesignerStrategy();
+                default:
+                    throw new NotImplementedException("hiring for " + person.Experience + " is not implemented");
+            }
+        }
+
+        private IInterviewStrategy GetDeveloperStrategy(InterviewedPerson person)
+        {
+            //It could get more complex, if we decide we want different process for different positions(part time/full time)
+            switch (person.Experience)
+            {
+                case Experience.Junior:
+                    return new JuniorDeveloperStrategy();
+                case Experience.Medium:
+                    return new MediumDeveloperStrategy();
+                case Experience.Senior:
+                    return new SeniorDeveloperStrategy();
+                case Experience.RockStar:
+                    return new RockstarDeveloperStrategy();
+                default:
+                    throw new NotImplementedException("hiring for " + person.Experience + " is not implemented");
+            }
+        }
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/DesignerStrategies.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class JuniorDesignerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with any medium/senior designer");
+        }
+    }
+
+    public class MediumDesignerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Give him medium designer test");
+            Console.WriteLine("Reserve a meeting with any senior designer");
+        }
+    }
+
+    public class SeniorDesignerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Give him a website to design");
+            Console.WriteLine("Reserve a meeting with any 2 senior desginers");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+
+    public class RockstarDesignerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Give him a website to design");
+            Console.WriteLine("Reserve a meeting with best senior designers");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/DevOpStrategy.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class JuniorDevOpStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with any medium/senior DevOp");
+        }
+    }
+
+    public class MediumDevOpStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with any senior DevOps");
+        }
+    }
+
+    public class SeniorDevOpStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with any 2 senior DevOps");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+
+    public class RockstarDevOpStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with best senior DevOps");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/DeveloperStrategies.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class JuniorDeveloperStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Prepare junior developer interview questions");
+            Console.WriteLine("Reserve a meeting with any medium/senior developer");
+        }
+    }
+
+    public class MediumDeveloperStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Prepare medium developer interview questions");
+            Console.WriteLine("Give him a small program to develop before he comes here");
+            Console.WriteLine("Reserve a meeting with any senior developer");
+        }
+    }
+
+    public class SeniorDeveloperStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Give him a complex program to develop before he comes here");
+            Console.WriteLine("Prepare senior tester interview questions");
+            Console.WriteLine("Reserve a meeting with any 2 senior developers");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+
+    public class RockstarDeveloperStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("We don't hire rockstar developers, because they are too cocky, this title was a trap");
+        }
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/IInterviewStrategy.cs

@@ -0,0 +1,7 @@
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public interface IInterviewStrategy
+    {
+        void Arrange(InterviewedPerson person);
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/ManagerStratgies.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class JuniorManagerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("We don't hire junior managers");
+        }
+    }
+
+    public class MediumFullTimeManagerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserve a meeting with one of the managers");
+        }
+    }
+
+    public class MediumNonFullTimeManagerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("We dont hire Medium managers only full time");
+        }
+    }
+
+    public class SeniorAndRockstarManagerStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Reserver a meeting with all the managers");
+        }
+    }
+}

src/StrategyPattern/ArrangeInterview/Strategy/TestingStrategies.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace StrategyPattern.ArrangeInterview.Strategy
+{
+    public class JuniorTesterStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Prepare junior tester interview questions");
+            Console.WriteLine("Reserve a meeting with any medium/senior tester"); ;
+        }
+    }
+
+    public class MediumTesterStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Prepare medium tester interview questions");
+            Console.WriteLine("Reserve a meeting with any senior tester");
+        }
+    }
+
+    public class SeniorTestingStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("Prepare senior tester interview questions");
+            Console.WriteLine("Reserve a meeting with any 2 senior testers");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+
+    public class RockstarTestingStrategy : IInterviewStrategy
+    {
+        public void Arrange(InterviewedPerson person)
+        {
+            Console.WriteLine("get third party rockstar testers to test him out");
+            Console.WriteLine("Reserver a meeting with one of the managers");
+        }
+    }
+}