public EnterpriseDataService(IIdentifier identifier, IEnterpriseDataRepository repository, IPersonsUploader uploader)
 {
     _identifier = identifier;
     _enterpriseRepository = repository;
     _uploader = uploader;
     _enterpriseId = _identifier.EnterpriseId(System.Threading.Thread.CurrentPrincipal.Identity.Name);
 }

 public AuthorizationHideForSessionFacet(IIdentifier identifier,
                                         IAuthorizationManager authorizationManager,
                                         ISpecification holder)
     : base(holder) {
     this.identifier = identifier;
     this.authorizationManager = authorizationManager;
 }

 public SecurityHideForSessionFacet(IIdentifier identifier,
                                    SecurityFacetDecorator decorator,
                                    IFacetHolder holder)
     : base(holder) {
     this.identifier = identifier;
     this.decorator = decorator;
 }

 public DescribedAsFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, IDescribedAsFacet describedAsFacet, int index = -1)
     : base(Type, holder) {
     this.manager = manager;
     this.identifier = identifier;
     this.describedAsFacet = describedAsFacet;
     this.index = index;
 }

        public NamedFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, INamedFacet namedFacet, int index = -1)
            : base(Type, holder) {
            this.manager = manager;
            this.identifier = identifier;
            this.namedFacet = namedFacet;

            this.index = index;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="AssignmentStatement"/> class.
 /// </summary>
 /// <param name="id">The identifier.</param>
 /// <param name="expression">The expression.</param>
 public AssignmentStatement(IIdentifier id, IExpression expression)
 {
     if (id == null) throw new ArgumentNullException("id");
     if (expression == null) throw new ArgumentNullException("expression");
     this.ID = id;
     this.ID.Type = expression.Type;
     this.Expression = expression;
 }

        public WithScope(WithScope parent, IIdentifier identifier)
        {
            if (identifier == null)
                throw new ArgumentNullException("identifier");

            Parent = parent;
            Identifier = identifier;
        }

        public VariableDeclaration(IIdentifier identifier, ExpressionSyntax expression, bool global)
        {
            if (identifier == null)
                throw new ArgumentNullException("identifier");

            Identifier = identifier;
            Expression = expression;
            Global = global;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="FunctionCallExpression"/> class.
 /// </summary>
 /// <param name="identifier">The identifier.</param>
 /// <param name="argumentList">The argument list.</param>
 /// <exception cref="System.ArgumentNullException">argumentList or identifier</exception>
 public FunctionCallExpression(IIdentifier identifier, IArgumentList argumentList)
 {
     if (argumentList == null)
         throw new ArgumentNullException("argumentList");
     if (identifier == null)
         throw new ArgumentNullException("identifier");
     this.ArgumentList = argumentList;
     this.Identifier = identifier;
 }

        public CatchClause(IIdentifier identifier, SyntaxNode statement)
        {
            if (identifier == null)
                throw new ArgumentNullException("identifier");
            if (statement == null)
                throw new ArgumentNullException("statement");

            Identifier = identifier;
            Body = statement;
        }

        public bool IsVisible(ISession session, INakedObject target, IIdentifier member) {
            var checkViewType = member.IsField ? CheckType.ViewField : CheckType.Action;
            var checkEditType = member.IsField ? CheckType.EditField : CheckType.Action;

            var contextView = new AuthorizationContext((ClaimsPrincipal)session.Principal, member.ToIdentityString(IdentifierDepth.ClassName), ((int)checkViewType).ToString());
            var contextEdit = new AuthorizationContext((ClaimsPrincipal)session.Principal, member.ToIdentityString(IdentifierDepth.ClassName), ((int)checkEditType).ToString());

            // being editable implies visibility 
            return manager.CheckAccess(contextView) || manager.CheckAccess(contextEdit);
        }

        public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) {
            object authorizer = GetAuthorizer(target, lifecycleManager);
            Type authType = authorizer.GetType();

            if ((typeof(INamespaceAuthorizer)).IsAssignableFrom(authType)) {
                var nameAuth = (INamespaceAuthorizer) authorizer;
                return nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName);
            }
            return isEditableDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName);
        }

        public void Invoke(INakedObject nakedObject, INakedObject[] parameters, bool queryOnly, IIdentifier identifier) {
            Init();
            IAuditor auditor = GetNamespaceAuthorizerFor(nakedObject) ?? defaultAuditor;

            if (nakedObject.Specification.IsService) {
                string serviceName = nakedObject.Specification.GetTitle(nakedObject);
                auditor.ActionInvoked(NakedObjectsContext.Session.Principal, identifier.MemberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
            else {
                auditor.ActionInvoked(NakedObjectsContext.Session.Principal, identifier.MemberName, nakedObject.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
        }

        public void Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, bool queryOnly, IIdentifier identifier, ISession session, ILifecycleManager lifecycleManager) {
            IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager);

            IPrincipal byPrincipal = session.Principal;
            string memberName = identifier.MemberName;
            if (nakedObjectAdapter.Spec is IServiceSpec) {
                string serviceName = nakedObjectAdapter.Spec.GetTitle(nakedObjectAdapter);
                auditor.ActionInvoked(byPrincipal, memberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
            else {
                auditor.ActionInvoked(byPrincipal, memberName, nakedObjectAdapter.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
        }

 /// <summary>
 /// Returns true when the name comparison is a special case and should not 
 /// be used to determine name conflicts.
 ///  </summary>
 /// <param name="whoIsAsking">the identifier that is checking to see if there is a conflict</param>
 /// <param name="reservedName">the identifier that would normally be reserved.</param>
 /// <returns></returns>
 public override bool IsSpecialCase(IIdentifier whoIsAsking, IIdentifier reservedName)
 {
     if (whoIsAsking is Property && reservedName is CompositeType)
     {
         var parent = (whoIsAsking as IChild)?.Parent as IIdentifier;
         if (ReferenceEquals(parent, reservedName))
         {
             return false;
         }
         // special case: properties can have the same name as a compositetype
         // unless it is the same name as a parent.
         return true;
     }
     return false;
 }

 private InteractionContext(InteractionType interactionType,
                            ISession session,
                            bool programmatic,
                            INakedObjectAdapter target,
                            IIdentifier id,
                            INakedObjectAdapter proposedArgument,
                            INakedObjectAdapter[] arguments) {
     this.interactionType = interactionType;
     this.programmatic = programmatic;
     this.id = id;
     this.session = session;
     this.target = target;
     this.proposedArgument = proposedArgument;
     proposedArguments = arguments;
 }

        public EquationBuilder CreateItem(IIdentifier identifier, out IItem item)
        {
            var selectedFactories = Factories.Where(factory => factory.CanCreate(identifier));

            switch(selectedFactories.Count())
            {
                case 0:
                    throw new ArgumentException("no factory available");
                case 1: item = selectedFactories.First().Create(identifier);
                    break;
                default:
                    throw new ArgumentException("more than one factory can create a such item");
            }

            return this;
        }

        private IFacet GetDescriptionFacet(IFacetHolder holder, IDescribedAsFacet facet, IIdentifier identifier) {
            string i18nDescription;
            string original = (facet).Value;
            if (holder is NakedObjectActionParameterAbstract) {
                int index = ((NakedObjectActionParameterAbstract) holder).Number;
                i18nDescription = i18nManager.GetParameterDescription(identifier, index, original);

                if (!staticFacets) {
                    return new DescribedAsFacetDynamicWrapI18n(i18nManager, holder, identifier, facet, index);
                }
            }
            else {
                i18nDescription = i18nManager.GetDescription(identifier, original);

                if (!staticFacets) {
                    return new DescribedAsFacetDynamicWrapI18n(i18nManager, holder, identifier, facet);
                }
            }
            return i18nDescription == null ? null : new DescribedAsFacetWrapI18n(i18nDescription, facet.FacetHolder);
        }

        private IFacet GetNamedFacet(IFacetHolder holder, INamedFacet facet, IIdentifier identifier) {
            string original = (facet).Value ?? NameUtils.NaturalName(identifier.MemberName);
            string i18nName;
            if (holder is NakedObjectActionParameterAbstract) {
                int index = ((NakedObjectActionParameterAbstract) holder).Number;
                i18nName = i18nManager.GetParameterName(identifier, index, original);

                if (!staticFacets) {
                    return new NamedFacetDynamicWrapI18n(i18nManager, holder, identifier, facet, index);
                }
            }
            else {
                i18nName = i18nManager.GetName(identifier, original);

                if (!staticFacets) {
                    return new NamedFacetDynamicWrapI18n(i18nManager, holder, identifier, facet);
                }
            }
            return i18nName == null ? null : new NamedFacetWrapI18n(i18nName, facet.FacetHolder);
        }

 private string GetText(IIdentifier identifier, string type) {
     string form = identifier.IsField ? Property : Action;
     string key = identifier.ToIdentityString(IdentifierDepth.ClassNameParams) + ":" + form + "/" + type;
     return GetText(key);
 }