public IHttpActionResult GetCollaborationUsers(string mappingName, Guid workflowInstanceId, string internalActivityId)
        {
            _logger.WriteDebug(new LogMessage(string.Concat("GetCollaborationUsers -> mappingName = ", mappingName, ", workflowInstanceId = ", workflowInstanceId, ", internalActivityId = ", internalActivityId)), LogCategories);
            return(CommonHelpers.ActionHelper.TryCatchWithLoggerGeneric <IHttpActionResult>(() =>
            {
                ICollection <CollaborationUserModel> users = new List <CollaborationUserModel>();
                if (string.IsNullOrEmpty(mappingName))
                {
                    _logger.WriteError(new LogMessage("GetCollaborationUsers -> Errore validazione parametri in ingresso, mappingName non valorizzato"), LogCategories);
                    return BadRequest("GetCollaborationUsers -> Errore validazione parametri in ingresso, mappingName non valorizzato");
                }

                WorkflowRepository repository = _unitOfWork.Repository <WorkflowRepository>().GetByInstanceId(workflowInstanceId);
                if (repository == null)
                {
                    _logger.WriteError(new LogMessage("Nessun repository trovato"), LogCategories);
                    return BadRequest("Nessun repository trovato");
                }
                IEnumerable <WorkflowRoleMapping> workflowRoleMappings;
                if (string.IsNullOrEmpty(internalActivityId))
                {
                    workflowRoleMappings = _unitOfWork.Repository <WorkflowRoleMapping>().GetByMappingTag(mappingName, repository.UniqueId);
                }
                else
                {
                    workflowRoleMappings = _unitOfWork.Repository <WorkflowRoleMapping>().GetByMappingTag(mappingName, repository.UniqueId, internalActivityId);
                }

                short incremental = 1;
                foreach (WorkflowRoleMapping workflowRoleMapping in workflowRoleMappings)
                {
                    CollaborationUserModel collaborationUser = new CollaborationUserModel();
                    if (workflowRoleMapping.AuthorizationType == WorkflowAuthorizationType.UserName)
                    {
                        DomainUserModel user = _security.GetUser(workflowRoleMapping.AccountName);
                        collaborationUser = _domainUserMapper.Map(user, new CollaborationUserModel());
                        collaborationUser.Account = workflowRoleMapping.AccountName;
                    }
                    else
                    {
                        collaborationUser = _mapperCollaborationUser.Map(workflowRoleMapping, collaborationUser);
                    }
                    collaborationUser.Incremental = incremental++;
                    users.Add(collaborationUser);
                }

                return Ok(users);
            }, _logger, LogCategories));
        }
        public IHttpActionResult GetCollaborationUsers(string domain, string account)
        {
            _logger.WriteDebug(new LogMessage(string.Concat("GetCollaborationUsers -> domain = ", domain, ", account = ", account)), LogCategories);
            return(CommonHelpers.ActionHelper.TryCatchWithLoggerGeneric <IHttpActionResult>(() =>
            {
                ICollection <CollaborationUserModel> users = new List <CollaborationUserModel>();
                if (string.IsNullOrEmpty(account))
                {
                    _logger.WriteError(new LogMessage("GetCollaborationUsers -> Errore validazione parametri in ingresso, account non valorizzato"), LogCategories);
                    return BadRequest("GetCollaborationUsers -> Errore validazione parametri in ingresso, account non valorizzato");
                }

                DomainUserModel user = _security.GetUser(account);
                CollaborationUserModel collaborationUser = _domainUserMapper.Map(user, new CollaborationUserModel());
                collaborationUser.Account = account;
                collaborationUser.Incremental = 1;
                users.Add(collaborationUser);
                return Ok(users);
            }, _logger, LogCategories));
        }
        public IHttpActionResult GetCollaborationUsers(int?roleId)
        {
            _logger.WriteDebug(new LogMessage(string.Concat("GetCollaborationUsers -> roleId = ", roleId)), LogCategories);
            return(CommonHelpers.ActionHelper.TryCatchWithLoggerGeneric <IHttpActionResult>(() =>
            {
                ICollection <CollaborationUserModel> users = new List <CollaborationUserModel>();
                if (!roleId.HasValue)
                {
                    _logger.WriteError(new LogMessage("GetCollaborationUsers -> Errore validazione parametri in ingresso, roleId non valorizzato"), LogCategories);
                    return BadRequest("GetCollaborationUsers -> Errore validazione parametri in ingresso, roleId non valorizzato");
                }

                Role role = _unitOfWork.Repository <Role>().Find(roleId.Value);
                WorkflowRoleMapping workflowRoleMapping = new WorkflowRoleMapping()
                {
                    Role = role
                };
                CollaborationUserModel collaborationUser = _mapperCollaborationUser.Map(workflowRoleMapping, new CollaborationUserModel());
                collaborationUser.Incremental = 1;
                users.Add(collaborationUser);
                return Ok(users);
            }, _logger, LogCategories));
        }