public bool IsWarewolfAuthorised(string privilege, string userName, IWarewolfResource resource)
{
var unqualifiedUserName = GetUnqualifiedName(userName).Trim();
IPrincipal identity;
try
{
identity = new WindowsPrincipal(new WindowsIdentity(unqualifiedUserName));
}
catch (Exception e)
{
Dev2Logger.Warn("Failed to get windows security principal for " + unqualifiedUserName + " as a windows identity. " + e.Message, GlobalConstants.WarewolfWarn);
var groups = GetGroupsUserBelongsTo(unqualifiedUserName, GetAccountsWithPrivilege(privilege));
var tmp = new GenericIdentity(unqualifiedUserName);
identity = new GenericPrincipal(tmp, groups.ToArray());
}
if (_authorizationService.IsAuthorized(identity, AuthorizationContext.Execute, resource))
{
return(true);
}
Dev2Logger.Warn("User " + unqualifiedUserName + " was denied permission to create a scheduled task.", GlobalConstants.WarewolfWarn);
return(false);
}
string GetExecutePayload(IDSFDataObject dataObject, IWarewolfResource resource, WebRequestTO webRequest, ref DataListFormat formatter)
{
var notDebug = !dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke;
if (notDebug && resource?.DataList != null)
{
switch (dataObject.ReturnType)
{
case EmitionTypes.XML:
{
return(ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0));
}
case EmitionTypes.SWAGGER:
{
formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json");
return(ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource, resource.DataList.ToString(), webRequest.WebServerUrl));
}
default:
case EmitionTypes.JSON:
{
formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json");
return(ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0));
}
}
}
return(string.Empty);
}
public static string GetSwaggerOutputForService(IWarewolfResource resource, string dataList, string webServerUrl)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (string.IsNullOrEmpty(dataList))
{
throw new ArgumentNullException(nameof(dataList));
}
Uri.TryCreate(webServerUrl, UriKind.RelativeOrAbsolute, out Uri url);
var jsonSwaggerInfoObject = BuildJsonSwaggerInfoObject(resource);
var definitionObject = GetParametersDefinition(out List <JObject> parameters, dataList, out bool isScalarInputOnly);
var parametersForSwagger = isScalarInputOnly ? (JToken) new JArray(parameters) : new JArray(new JObject {
{ "name", "DataList" }, { "in", "query" }, { "required", true }, { "schema", new JObject {
{ "$ref", "#/definitions/DataList" }
} }
});
var jsonSwaggerPathObject = BuildJsonSwaggerPathObject(url.AbsolutePath, parametersForSwagger);
var jsonSwaggerResponsesObject = BuildJsonSwaggerResponsesObject();
var jsonSwaggerObject = BuildJsonSwaggerObject(jsonSwaggerInfoObject, jsonSwaggerPathObject, jsonSwaggerResponsesObject, definitionObject, url.Scheme);
var resultString = GetSerializedSwaggerObject(jsonSwaggerObject);
return(resultString);
}
static JObject BuildJsonSwaggerInfoObject(IWarewolfResource resource)
{
var versionValue = resource.VersionInfo != null ? new JValue(resource.VersionInfo.VersionNumber) : new JValue("1.0.0");
var jsonSwaggerInfoObject = new JObject
{
{ "title", new JValue(resource.ResourceName) },
{ "description", new JValue("") },
{ "version", versionValue }
};
return(jsonSwaggerInfoObject);
}
public static void SetResourceNameAndId(this IDSFDataObject dataObject, IResourceCatalog catalog, string serviceName, out IWarewolfResource resource)
{
IWarewolfResource localResource = null;
if (Guid.TryParse(serviceName, out var resourceId))
{
localResource = catalog.GetResource(dataObject.WorkspaceID, resourceId);
if (localResource != null)
{
MapServiceToDataObjects(dataObject, localResource);
}
}
else
{
if (!string.IsNullOrEmpty(dataObject.ServiceName))
{
localResource = catalog.GetResource(dataObject.WorkspaceID, dataObject.ServiceName);
if (localResource != null)
{
dataObject.ResourceID = localResource.ResourceID;
dataObject.SourceResourceID = localResource.ResourceID;
}
}
}
if (localResource == null)
{
var stringDynaResourceId = serviceName.Replace(".xml", "").Replace(".bite", "").Replace(".json", "");
if (Guid.TryParse(stringDynaResourceId, out resourceId))
{
localResource = catalog.GetResource(dataObject.WorkspaceID, resourceId);
if (localResource != null)
{
MapServiceToDataObjects(dataObject, localResource);
}
}
if (localResource == null)
{
dataObject.Environment.AddError($"Service {serviceName} not found.");
}
}
resource = localResource;
dataObject.Resource = resource;
}
public static bool CanExecuteCurrentResource(this IDSFDataObject dataObject, IWarewolfResource resource, IAuthorizationService service)
{
if (resource is null)
{
return(false);
}
var canExecute = true;
if (service != null && dataObject.ReturnType != EmitionTypes.TRX)
{
var hasView = service.IsAuthorized(dataObject.ExecutingUser, AuthorizationContext.View, resource);
var hasExecute = service.IsAuthorized(dataObject.ExecutingUser, AuthorizationContext.Execute, resource);
canExecute = (hasExecute && hasView) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource.ResourceType == "ReservedService");
}
return(canExecute);
}
private void SetWarewolfTestResults(ITestCatalog testCatalog, IWarewolfResource coverageResource)
{
var workflowTestResults = new WorkflowTestResults(testCatalog, coverageResource);
if (!string.IsNullOrEmpty(_reportName) && _reportName != "*")
{
var report = testCatalog.Fetch(coverageResource.ResourceID);
var tempcoverageReport = report?.Find(oo => oo.TestName?.ToUpper() == _reportName.ToUpper());
if (tempcoverageReport != null)
{
AllTestResults.Add(tempcoverageReport);
}
}
else
{
workflowTestResults.Results
?.ForEach(o => AllTestResults.Add(o));
}
}
public static string GetOpenAPIOutputForService(IWarewolfResource resource, string dataList, string webServerUrl)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (string.IsNullOrEmpty(dataList))
{
throw new ArgumentNullException(nameof(dataList));
}
Uri.TryCreate(webServerUrl, UriKind.RelativeOrAbsolute, out Uri url);
var jsonOpenAPIInfoObject = BuildJsonOpenAPIInfoObject(resource);
var jsonOpenAPIServerObject = BuildJsonOpenAPIServerObject(url);
var jsonOpenAPIPathObject = BuildJsonOpenAPIPathObject(url.PathAndQuery, dataList);
var jsonOpenAPIObject = BuildJsonOpenAPIObject(jsonOpenAPIInfoObject, jsonOpenAPIServerObject, jsonOpenAPIPathObject);
var resultString = GetSerializedOpenAPIObject(jsonOpenAPIObject);
return(resultString);
}
public static bool Matches(this WindowsGroupPermission permission, IWarewolfResource resource)
{
if (permission.IsServer)
{
return(true);
}
var matchingResourceID = permission.ResourceID == resource?.ResourceID;
if (matchingResourceID)
{
return(true);
}
var resourcePath = resource?.FilePath?.Replace('/', '\\');
if (string.IsNullOrEmpty(resourcePath))
{
return(true);
}
var p1 = resourcePath;
if (p1.StartsWith(EnvironmentVariables.ResourcePath))
{
p1 = p1.Replace(EnvironmentVariables.ResourcePath, "");
}
var permissionResourcePath = permission.ResourcePath;
if (permissionResourcePath is null)
{
return(false);
}
var p2 = "\\" + permissionResourcePath;
var pathMatches = p1.StartsWith(p2);
return(pathMatches);
}
public override bool IsAuthorized(AuthorizationContext context, IWarewolfResource resource)
{
return(IsAuthorized(context, resource?.ResourceID ?? Guid.Empty));
}
public WorkflowTestResults(IWarewolfResource res)
{
Resource = res;
}
public WorkflowTestResults(ITestCatalog testCatalog, IWarewolfResource res)
{
_testCatalog = testCatalog;
Resource = res;
Initialize();
}
private IResponseWriter ExecuteAsCoverage(WebRequestTO webRequest, string serviceName, IWarewolfResource resource)
{
try
{
var coverageDataContext = new CoverageDataContext(_dataObject.ResourceID, _dataObject.ReturnType, webRequest.WebServerUrl);
coverageDataContext.SetTestCoverageResourceIds(_resourceCatalog.NewContextualResourceCatalog(_authorizationService, _workspaceGuid), webRequest, serviceName, resource);
var formatter = ServiceTestCoverageExecutor.GetTestCoverageReports(coverageDataContext, _workspaceGuid, _serializer, _testCoverageCatalog, _resourceCatalog, out _executePayload);
return(new StringResponseWriter(_executePayload ?? string.Empty, formatter.ContentType));
}
finally
{
Dev2DataListDecisionHandler.Instance.RemoveEnvironment(_dataObject.DataListID);
_dataObject.Environment = null;
}
}
private void PrepareDataObject(WebRequestTO webRequest, string serviceName, NameValueCollection headers, IPrincipal user, Guid workspaceGuid, out IWarewolfResource resource)
{
var uri = string.IsNullOrWhiteSpace(webRequest.WebServerUrl) ? new Uri("https://test/") : new Uri(webRequest.WebServerUrl);
_dataObject = _dataObjectFactory.New(workspaceGuid, user, serviceName, webRequest);
_dataObject.OriginalServiceName = serviceName;
_dataObject.SetHeaders(headers);
_dataObject.SetupForWebDebug(webRequest);
webRequest.BindRequestVariablesToDataObject(ref _dataObject);
_dataObject.SetupForRemoteInvoke(headers);
_dataObject.SetEmissionType(uri, serviceName, headers);
_dataObject.SetupForTestExecution(serviceName, headers);
if (_dataObject.ServiceName == null)
{
_dataObject.ServiceName = serviceName;
}
_dataObject.SetResourceNameAndId(_resourceCatalog, serviceName, out resource);
_dataObject.SetTestResourceIds(_resourceCatalog.NewContextualResourceCatalog(_authorizationService, workspaceGuid), webRequest, serviceName, resource);
_dataObject.WebUrl = webRequest.WebServerUrl;
_dataObject.EsbChannel = new EsbServicesEndpoint();
if (_dataObject.Settings is null)
{
_dataObject.Settings = new Dev2WorkflowSettingsTO
{
EnableDetailedLogging = Config.Server.EnableDetailedLogging,
LoggerType = LoggerType.JSON,
KeepLogsForDays = 2,
CompressOldLogFiles = true
};
}
var stateNotifier = CustomContainer.Get <IStateNotifierFactory>()?.New(_dataObject);
_dataObject.StateNotifier = stateNotifier;
}
public static bool IsExecutable(this IWarewolfResource resource, IsAuthorizedCallback isAuthorized)
{
VerifyArgument.IsNotNull(nameof(isAuthorized), isAuthorized);
return(isAuthorized.Invoke(AuthorizationContext.Execute, resource.ResourceID.ToString()));
}
public override bool IsAuthorized(AuthorizationContext context, IWarewolfResource resource)
{
return(IsAuthorized(User, context, resource));
}
public static void SetTestCoverageResourceIds(this ICoverageDataObject coverageData, IContextualResourceCatalog catalog, WebRequestTO webRequest, string serviceName, IWarewolfResource resource)
{
if (IsRunAllCoverageRequest(coverageData.ReturnType, serviceName))
{
var pathOfAllResources = webRequest.GetPathForAllResources();
var path = pathOfAllResources;
if (string.IsNullOrEmpty(pathOfAllResources))
{
path = "/";
}
var resources = catalog.GetExecutableResources(path);
coverageData.CoverageReportResourceIds = resources.Where(o => o is IWarewolfWorkflow).Select(p => p.ResourceID).GroupBy(o => o).Select(o => o.Key).ToArray();
}
else if (resource != null)
{
coverageData.CoverageReportResourceIds = new[] { resource.ResourceID };
}
}
public override bool IsAuthorized(AuthorizationContext context, IWarewolfResource resource)
{
var x = IsAuthorized(_environmentConnection.Principal, context, resource);
return(x);
}
static void MapServiceToDataObjects(IDSFDataObject dataObject, IWarewolfResource localResource)
{
dataObject.ServiceName = localResource.ResourceName;
dataObject.ResourceID = localResource.ResourceID;
dataObject.SourceResourceID = localResource.ResourceID;
}
public override bool IsAuthorized(Dev2.Common.Interfaces.Enums.AuthorizationContext context, IWarewolfResource resource)
{
return(IsAuthorized(context, resource?.ResourceID ?? Guid.Empty));
}