/// <summary>

        /// Check if currentStatus is before (order == -1) or after (order == 1) limitStatuses

        /// </summary>

        /// <param name="currentStatusCode"></param>

        /// <param name="limitStatusesCodes"></param>

        /// <param name="order"></param>

        /// <returns>bool</returns>

        public bool CompareStatusOrder(string currentStatusCode, List<string> limitStatusesCodes, int order = -1)

        {

            if (order != -1 && order != 1)

            {

                throw new InvalidOperationException("Invalid order parameter, should be '-1' (before) or '1' (after)");

            }

​

            // Current status is the status you want to compare with limit statuses,

            // meaning you want to know if current status is before or after limit statuses

            NH90CM_Status currentStatus = context.NH90CM_Status.Where(status => status.Code == currentStatusCode).First();

            if (currentStatus == null)

            {

                throw new InvalidOperationException("Unknown NH90Status code " + currentStatusCode);

            }

​

            List<NH90CM_Status> limitStatuses = context.NH90CM_Status.Where(status => limitStatusesCodes.Contains(status.Code)).ToList();

            if (limitStatuses == null)

            {

                throw new InvalidOperationException("Unknown NH90Status codes " + limitStatusesCodes);

            }

​

            // Get all transitions where limit statuses are fromStatus or toStatus depending on order

            List<NH90CM_StatusTransition> transitions = context.NH90CM_StatusTransition.Where(transition =>

                limitStatusesCodes.Contains(order == -1 ? transition.ToStatus.Code : transition.FromStatus.Code) && !transition.IsRegression

            ).ToList();

​

            bool statusIsIncludes = transitions.Any(transition => order == -1 ?

                transition.FromStatus.Code.Equals(currentStatusCode, StringComparison.OrdinalIgnoreCase) :

                transition.ToStatus.Code.Equals(currentStatusCode, StringComparison.OrdinalIgnoreCase));

​

            // If transitions.fromStatus or transitions.toStatus contains current status,

            // it means that current status is before of after the limit statuses

            if (statusIsIncludes)

            {

                return true;

            }

            // If no transition was found, it means that we reached the top of transitions workflow

            // or if limit statuses contains current status, it means that we won't find current status in parent's transitions

            else if (transitions.Count == 0 || limitStatusesCodes.Contains(currentStatusCode))

            {

                return false;

            }

            // We have to back up one level of transitions to check parent statuses of limit statuses

            else

            {

                List<string> newLimitStatusesCode = order == -1 ?

                    transitions.Select(t => t.FromStatus.Code).Distinct().ToList() :

                    transitions.Select(t => t.ToStatus.Code).Distinct().ToList();

​

                // If new and old limit statuses are equals, we can stop the loop

                return newLimitStatusesCode.OrderBy(t => t).SequenceEqual(limitStatusesCodes.OrderBy(t => t)) ?

                    false : CompareStatusOrder(currentStatusCode, newLimitStatusesCode, order);

            }

        }