예제 #1
0
        static void Display <T>(HierarchyResult <T> hierarchy, Func <T, IEnumerable <T> > collectionIdentifier, Func <T, string> print) where T : class
        {
            if (hierarchy == null)
            {
                return;
            }

            if (hierarchy.HasError)
            {
                System.Console.ForegroundColor = ConsoleColor.Red;
                System.Console.WriteLine("ERROR : {0}", hierarchy.Exception.Message);
                System.Console.ResetColor();
            }
            else
            {
                Action <T, string> displayFunc = null;
                displayFunc = (entity, tabFormat) =>
                {
                    if (entity == null)
                    {
                        return;
                    }

                    if (string.IsNullOrEmpty(tabFormat))
                    {
                        System.Console.Write("\n{0}", print(entity));
                    }
                    else
                    {
                        System.Console.Write("\n{0}{1}", tabFormat, print(entity));
                    }

                    if (collectionIdentifier(entity).Any())
                    {
                        var collection = collectionIdentifier(entity);
                        tabFormat += "\t";
                        foreach (var teamMember in collection)
                        {
                            displayFunc(teamMember, tabFormat);
                        }
                    }
                };

                foreach (var executive in hierarchy.Executives)
                {
                    displayFunc(executive.Value, "");
                }
            }
        }
예제 #2
0
        static void Display(HierarchyResult hierarchy)
        {
            if (hierarchy == null)
            {
                return;
            }

            if (hierarchy.HasError)
            {
                System.Console.ForegroundColor = ConsoleColor.Red;
                System.Console.WriteLine("ERROR : {0}", hierarchy.Exception.Message);
                System.Console.ResetColor();
            }
            else
            {
                Action <Employee, string> displayFunc = null;
                displayFunc = (employee, tabFormat) =>
                {
                    if (employee == null)
                    {
                        return;
                    }

                    if (string.IsNullOrEmpty(tabFormat))
                    {
                        System.Console.Write("\n{0}", employee.Name);
                    }
                    else
                    {
                        System.Console.Write("\n{0}{1}", tabFormat, employee.Name);
                    }

                    if (employee.Team != null && employee.Team.Any())
                    {
                        tabFormat += "\t";
                        foreach (var teamMember in employee.Team)
                        {
                            displayFunc(teamMember, tabFormat);
                        }
                    }
                };

                foreach (var executiveTeam in hierarchy.Executives)
                {
                    displayFunc(executiveTeam.Value, "");
                }
            }
        }
예제 #3
0
        static HierarchyResult GetHierarchy(IEnumerable <Employee> employees)
        {
            var hierarchy = new HierarchyResult();

            try
            {
                var employeeList = employees as List <Employee> ?? new List <Employee>(employees);
                if (employeeList.Any() == false)
                {
                    return(new HierarchyResult
                    {
                        Exception = new Exception("Please provide employees")
                    });
                }



                var employeesMappedById = employeeList.GroupBy(emp => emp.Id).ToDictionary(grp => grp.Key, grp => grp.Single());

                //
                // A dictionary to maintain who are the employees which we have already discovered
                //
                var visitedEmployees = new Dictionary <int, Employee>();
                //
                // Recursive function, to go through employees, and oragnize their teams
                //
                Action <IDictionary <int, Employee>, Employee, Employee> recursive = null;
                recursive = (dict, employee, subOrdinate) =>
                {
                    //
                    // If the structure already has an error, no need to continue
                    //
                    if (hierarchy.HasError)
                    {
                        return;
                    }
                    //
                    // If there's a subordinate to the passed employee add him to the "emp" team
                    //
                    if (subOrdinate != null)
                    {
                        employee.Team.Add(subOrdinate);
                    }
                    //
                    // If we have already processed the current employee, no need to continue further
                    //
                    if (visitedEmployees.ContainsKey(employee.Id))
                    {
                        return;
                    }
                    //
                    // If the employee has a manager, recursively call the function again, passing the employee as a "subordinate"
                    // of his manager (in this case the "manager")
                    //
                    if (employee.ManagerId.HasValue)
                    {
                        //
                        // If the manager is not a valid employee, set the error message
                        //
                        if (dict.ContainsKey(employee.ManagerId.Value))
                        {
                            recursive(dict, dict[employee.ManagerId.Value], employee);
                        }
                        else
                        {
                            hierarchy.Exception = new Exception(string.Format("Invalid employee with Id:[{0}]", employee.ManagerId));
                        }
                    }
                    else
                    {
                        if (hierarchy.Executives.ContainsKey(employee.Id) == false)
                        {
                            hierarchy.Executives.Add(employee.Id, employee);
                        }
                    }

                    visitedEmployees.Add(employee.Id, employee);
                };

                //
                // Call the function to build the hierarchy
                //
                foreach (var employee in employeeList)
                {
                    recursive(employeesMappedById, employee, null);
                }
            }
            catch (InvalidOperationException exception)
            {
                hierarchy.Exception = new Exception("Employee id's are not unique");
            }
            catch (Exception exception)
            {
                hierarchy.Exception = new Exception("Cannot create the hierarchy");
            }

            return(hierarchy);
        }
예제 #4
0
        static HierarchyResult <T> GetHierarchy <T>(IEnumerable <T> collection,
                                                    Func <T, object> uniqueIdentifier,
                                                    Func <T, object> parentIdentifier,
                                                    Action <T, T> addFunc) where T : class
        {
            var hierarchy = new HierarchyResult <T>(uniqueIdentifier, parentIdentifier, addFunc);

            try
            {
                var list = collection as List <T> ?? new List <T>(collection);
                if (list.Any() == false)
                {
                    hierarchy.Exception = new Exception("Please provide employees");
                    return(hierarchy);
                }

                var entitiesMappedByKey = list.GroupBy(uniqueIdentifier).ToDictionary(grp => grp.Key, grp => grp.Single());

                //
                // A dictionary to maintain who are the employees which we have already discovered
                //
                var visitedEntitiesMappedByKey = new Dictionary <object, T>();
                //
                // Recursive function, to go through employees, and oragnize their teams
                //
                Action <IDictionary <object, T>, T, T> recursive = null;
                recursive = (dict, entity, childEntity) =>
                {
                    //
                    // If the structure already has an error, no need to continue
                    //
                    if (hierarchy.HasError)
                    {
                        return;
                    }
                    //
                    // If there's a subordinate to the passed employee add him to the "emp" team
                    //
                    if (childEntity != null)
                    {
                        addFunc(entity, childEntity);
                    }
                    //
                    // If we have already processed the current employee, no need to continue further
                    //
                    if (visitedEntitiesMappedByKey.ContainsKey(uniqueIdentifier(entity)))
                    {
                        return;
                    }
                    //
                    // If the employee has a manager, recursively call the function again, passing the employee as a "subordinate"
                    // of his manager (in this case the "manager")
                    //
                    var parentKeyValue = parentIdentifier(entity);
                    if (parentKeyValue != null)
                    {
                        //
                        // If the manager is not a valid employee, set the error message
                        //
                        if (dict.ContainsKey(parentKeyValue))
                        {
                            recursive(dict, dict[parentKeyValue], entity);
                        }
                        else
                        {
                            hierarchy.Exception = new Exception(string.Format("Invalid employee with Id:[{0}]", parentKeyValue));
                        }
                    }
                    else
                    {
                        if (hierarchy.Executives.ContainsKey(uniqueIdentifier(entity)) == false)
                        {
                            hierarchy.Executives.Add(uniqueIdentifier(entity), entity);
                        }
                    }

                    visitedEntitiesMappedByKey.Add(uniqueIdentifier(entity), entity);
                };

                //
                // Call the function to build the hierarchy
                //
                foreach (var employee in list)
                {
                    recursive(entitiesMappedByKey, employee, null);
                }
            }
            catch (InvalidOperationException exception)
            {
                hierarchy.Exception = new Exception(@"Provided unique identifier cannot identify entities distinctly");
            }
            catch (Exception exception)
            {
                hierarchy.Exception = new Exception("Cannot create the hierarchy");
            }

            return(hierarchy);
        }