public static bool TryGettingModelID(
IBDatabaseServiceInterface _DatabaseService,
string _RequestedModelName,
out string _ModelID,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction)
{
_FailureResponse = BWebResponse.InternalError("");
_ModelID = string.Empty;
if (!_DatabaseService.GetItem(
UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(),
UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME,
new BPrimitiveType(_RequestedModelName),
UniqueFileFieldsDBEntry.Properties,
out JObject ModelIDResponse,
_ErrorMessageAction) || !ModelIDResponse.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID))
{
_FailureResponse = BWebResponse.InternalError("Model ID could not be retrieved from the database.");
return(false);
}
_ModelID = (string)ModelIDResponse[ModelDBEntry.KEY_NAME_MODEL_ID];
return(true);
}
public override BWebServiceResponse OnRequest(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
bool bIsInternalCall =
BWebUtilities.DoesContextContainHeader(out List <string> ICHVs, out string _, _Context, "internal-call-secret") &&
BUtility.CheckAndGetFirstStringFromList(ICHVs, out string _);
if (bIsInternalCall)
{
var ErrorMessages = new JArray();
var Result = OnRequestPP(_Context, (string _Message) =>
{
_ErrorMessageAction?.Invoke(_Message);
ErrorMessages.Add(_Message);
});
try
{
if (Result.ResponseContent.Type == EBStringOrStreamEnum.String)
{
var Parsed = JObject.Parse(Result.ResponseContent.String);
Parsed["internalCallErrorMessages"] = ErrorMessages;
Result = new BWebServiceResponse(Result.StatusCode, Result.Headers, new BStringOrStream(Parsed.ToString()), Result.ResponseContentType);
}
}
catch (Exception) {}
return(Result);
}
return(OnRequestPP(_Context, _ErrorMessageAction));
}
public static bool GetProcessedFile(
WebServiceBaseTimeoutable _Request,
ENodeType _FileType,
IBDatabaseServiceInterface _DatabaseService,
IBFileServiceInterface _FileService,
string _CadFileStorageBucketName,
string _ModelID,
int _RevisionIndex,
out BWebServiceResponse _SuccessResponse,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_SuccessResponse = BWebResponse.InternalError("");
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(_Request.InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), _ModelID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Atomic operation control has failed.");
return(false);
}
var bResult = GetProcessedFile_Internal(
_FileType,
_DatabaseService,
_FileService,
_CadFileStorageBucketName,
_ModelID,
_RevisionIndex,
out _SuccessResponse,
out _FailureResponse,
_ErrorMessageAction);
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(_Request.InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), _ModelID, _ErrorMessageAction);
return(bResult);
}
public static bool FetchUserInfoFromDatabaseService_ByMethod(
IBDatabaseServiceInterface _DatabaseService,
IBMemoryServiceInterface _MemoryService,
string _Method,
out string _UserID,
out string _UserEmail,
out string _UserName,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_UserID = null;
_UserEmail = null;
_UserName = null;
_FailureResponse = new BWebServiceResponse();
string ReturnedEntryAsString = null;
if (!_DatabaseService.GetItem(
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
new BPrimitiveType(_Method),
AuthDBEntry.Properties,
out JObject ReturnedObject,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Database fetch operation has failed");
return(false);
}
if (ReturnedObject == null)
{
_ErrorMessageAction?.Invoke("FetchFromDatabaseService: Given credentials are invalid: " + _Method);
_FailureResponse = BWebResponse.Unauthorized("Given credentials are invalid.");
return(false);
}
try
{
ReturnedEntryAsString = ReturnedObject.ToString();
var ReturnedEntry = JsonConvert.DeserializeObject <AuthDBEntry>(ReturnedEntryAsString);
_UserID = ReturnedEntry.UserID;
_UserEmail = ReturnedEntry.UserEmail;
_UserName = ReturnedEntry.UserName;
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("FetchFromDatabaseService: " + e.Message + ", Trace: " + e.StackTrace);
_FailureResponse = BWebResponse.InternalError("Database fetch operation failed.");
return(false);
}
_MemoryService.SetKeyValue(CommonData.MemoryQueryParameters, new Tuple <string, BPrimitiveType>[]
{
new Tuple <string, BPrimitiveType>(AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + _Method, new BPrimitiveType(ReturnedEntryAsString))
},
_ErrorMessageAction);
return(true);
}
public static bool GetProcessedFileNode(
WebServiceBaseTimeoutable _Request,
ENodeType _FileType,
IBDatabaseServiceInterface _DatabaseService,
IBFileServiceInterface _FileService,
string _CadFileStorageBucketName,
string _ModelID,
int _RevisionIndex,
bool _bRootNodeRequested, ulong _NodeID,
out BWebServiceResponse _SuccessResponse,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_SuccessResponse = BWebResponse.InternalError("");
uint StartIndex = 0, Size = 0;
if (!_bRootNodeRequested)
{
Convert.UniqueIDToStartIndexAndSize(_NodeID, out StartIndex, out Size);
if (StartIndex == 0 || Size == 0)
{
_FailureResponse = BWebResponse.BadRequest("Invalid Node ID.");
return(false);
}
}
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(_Request.InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), _ModelID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Atomic operation control has failed.");
return(false);
}
var bResult = GetProcessedFileNode_Internal(
_FileType,
_DatabaseService,
_FileService,
_CadFileStorageBucketName,
_ModelID,
_RevisionIndex,
_bRootNodeRequested,
StartIndex,
Size,
out _SuccessResponse,
out _FailureResponse,
_ErrorMessageAction);
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(_Request.InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), _ModelID, _ErrorMessageAction);
return(bResult);
}
public bool AddRemoveMetadataSets_AttributesTables(
WebServiceBaseTimeoutableDeliveryEnsurerUserProcessor _Request,
string _UserID,
MetadataLocator _MetadataLocator,
List <Metadata> _MetadataList_Ref,
EAddRemove _Operation,
EKillProcedureIfGetClearanceFails _KillProcedureIfGetClearanceFails,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_FailureResponse = BWebResponse.InternalError("");
if (_MetadataList_Ref == null || _MetadataList_Ref.Count == 0)
{
return(true);
}
//Full copy
var MetadataList_Local = new List <Metadata>();
for (int i = 0; i < _MetadataList_Ref.Count; i++)
{
var Current = _MetadataList_Ref[i];
MetadataList_Local.Add(new Metadata()
{
MetadataKey = Current.MetadataKey,
MetadataValues = new List <string>(Current.MetadataValues)
});
}
var OperationInstance = new AddRemoveMetadataSets_AttributesTables_Operation();
if (!OperationInstance.ClearanceInstance.GetClearanceForAll(_Request, MetadataList_Local, _ErrorMessageAction))
{
if (_KillProcedureIfGetClearanceFails == EKillProcedureIfGetClearanceFails.Yes)
{
OperationInstance.ClearanceInstance.SetClearanceForObtained(_ErrorMessageAction);
_FailureResponse = BWebResponse.InternalError("Atomic operation control has failed.");
return(false);
}
}
//From now on, there should not be a case that it returns false.
OperationInstance.ProcedureInstance.Perform(_Request.CachedContext, _Operation, MetadataList_Local, _MetadataLocator, _UserID);
OperationInstance.ClearanceInstance.SetClearanceForObtained(_ErrorMessageAction);
return(true);
}
public static bool TryGettingAllInfo(
IBDatabaseServiceInterface _DatabaseService,
string _ModelID,
int _RevisionIndex,
out ModelDBEntry _ModelObject,
out Revision _RevisionObject,
out int _RevisionListIx,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_RevisionObject = null;
_RevisionListIx = -1;
_FailureResponse = BWebResponse.InternalError("");
if (!TryGettingModelInfo(
_DatabaseService,
_ModelID,
out JObject _,
true, out _ModelObject,
out BWebServiceResponse FailureResponse,
_ErrorMessageAction))
{
_FailureResponse = FailureResponse;
return(false);
}
if (!DoesRevisionExist(
_ModelObject,
_RevisionIndex,
out _RevisionObject,
out _RevisionListIx))
{
_FailureResponse = BWebResponse.NotFound("Revision does not exist.");
return(false);
}
return(true);
}
public static bool FetchBaseAccessRights_ByMethod(
IBDatabaseServiceInterface _DatabaseService,
IBMemoryServiceInterface _MemoryService,
string _Method,
out List <AccessScope> _AccessScopes,
out string _UserID,
out string _UserEmail,
out string _UserName,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_AccessScopes = null;
if (!FetchUserInfoFromMemoryService_ByMethod(_MemoryService, _Method, out _UserID, out _UserEmail, out _UserName, _ErrorMessageAction))
{
if (!FetchUserInfoFromDatabaseService_ByMethod(_DatabaseService, _MemoryService, _Method, out _UserID, out _UserEmail, out _UserName, out _FailureResponse, _ErrorMessageAction))
{
return(false);
}
}
return(FetchBaseAccessRights_ByUserID(_DatabaseService, _MemoryService, _UserID, out _AccessScopes, out _FailureResponse, _ErrorMessageAction));
}
public static bool TryGettingModelInfo(
IBDatabaseServiceInterface _DatabaseService,
string _ModelID,
out JObject _SuccessResultJson,
bool _bDeserialize, out ModelDBEntry _SuccessResultDeserialized,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_FailureResponse = BWebResponse.InternalError("");
_SuccessResultDeserialized = null;
var ModelKey = new BPrimitiveType(_ModelID);
if (!_DatabaseService.GetItem(
ModelDBEntry.DBSERVICE_MODELS_TABLE(),
ModelDBEntry.KEY_NAME_MODEL_ID,
ModelKey,
ModelDBEntry.Properties,
out _SuccessResultJson,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Database fetch-model-info operation has failed.");
return(false);
}
if (_SuccessResultJson == null)
{
_FailureResponse = BWebResponse.NotFound("Model does not exist.");
return(false);
}
if (_bDeserialize)
{
_SuccessResultDeserialized = JsonConvert.DeserializeObject <ModelDBEntry>(_SuccessResultJson.ToString());
}
return(true);
}
private bool Perform_SecondLeg_Authorization(
string _AuthorizationCode_From_FirstLeg,
BMemoryQueryParameters _SSOStateUniqueID_QueryParameters,
SSOStateMEntry _SSOState,
out AuthorizationResult _SuccessResponse,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction)
{
_SuccessResponse = null;
_FailureResponse = BWebResponse.InternalError("");
_SSOState.Status = SSOStateMEntry.STATUS_AUTHORIZING;
MemoryService.SetKeyValue(_SSOStateUniqueID_QueryParameters,
new Tuple <string, BPrimitiveType>[]
{
new Tuple <string, BPrimitiveType>(SSOStateMEntry.HASH_KEY, new BPrimitiveType(JsonConvert.SerializeObject(_SSOState)))
},
_ErrorMessageAction);
MemoryService.SetKeyExpireTime(_SSOStateUniqueID_QueryParameters, TimeSpan.FromSeconds(120), _ErrorMessageAction);
var FormUrlEncodedPairs = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("client_id", AzureAD_AppID),
new KeyValuePair <string, string>("scope", SSOCommon.SCOPE),
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("code", _AuthorizationCode_From_FirstLeg),
new KeyValuePair <string, string>("redirect_uri", WebUtility.UrlDecode(_SSOState.ServersideRedirectUrl)),
new KeyValuePair <string, string>("client_secret", WebUtility.UrlDecode(AzureAD_ClientSecret))
};
using var Handler = new HttpClientHandler
{
SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls,
ServerCertificateCustomValidationCallback = (a, b, c, d) => true
};
using var Client = new HttpClient(Handler);
Client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
string ResponseString = null;
try
{
using var RequestContent = new FormUrlEncodedContent(FormUrlEncodedPairs);
using var RequestTask = Client.PostAsync("https://login.microsoftonline.com/common/oauth2/v2.0/token", RequestContent);
RequestTask.Wait();
using var Response = RequestTask.Result;
using var ResponseContent = Response.Content;
using var ReadResponseTask = ResponseContent.ReadAsStringAsync();
ReadResponseTask.Wait();
ResponseString = ReadResponseTask.Result;
if (!Response.IsSuccessStatusCode)
{
bool bJsonParseable = true;
try { JObject.Parse(ResponseString); } catch (JsonReaderException) { bJsonParseable = false; }
_FailureResponse = new BWebServiceResponse(
(int)Response.StatusCode,
new BStringOrStream(ResponseString),
bJsonParseable ? "application/json" : "text/html");
return(false);
}
var Parsed = JObject.Parse(ResponseString);
_SuccessResponse = new AuthorizationResult()
{
TokenType = (string)Parsed["token_type"],
AccessToken = (string)Parsed["access_token"],
ExpiresInSeconds = (int)Parsed["expires_in"],
RefreshToken = (string)Parsed["refresh_token"]
};
}
catch (Exception e)
{
if (e.InnerException != null && e.InnerException != e)
{
_ErrorMessageAction?.Invoke("Error: SSOLoginCallback->Perform_SecondLeg_Authorization->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
}
if (e is AggregateException)
{
foreach (var Inner in (e as AggregateException).InnerExceptions)
{
_ErrorMessageAction?.Invoke("Error: SSOLoginCallback->Perform_SecondLeg_Authorization->Aggregate->Inner: " + Inner.Message + ", Trace: " + Inner.StackTrace);
}
}
_ErrorMessageAction?.Invoke("Error: SSOLoginCallback->Perform_SecondLeg_Authorization: Authorization request failed. Response: " + ResponseString + ", message: " + e.Message + ", trace: " + e.StackTrace);
_FailureResponse = BWebResponse.InternalError("Authorization request has failed.");
return(false);
}
MemoryService.DeleteAllKeys(_SSOStateUniqueID_QueryParameters, true, _ErrorMessageAction);
return(true);
}
private bool Parse_FirstLeg_Authentication_Content(
string _ResponseContent,
out string _AuthorizationCode_From_FirstLeg,
out BMemoryQueryParameters _SSOStateUniqueID_QueryParameters,
out SSOStateMEntry _SSOState,
out string _LocalRedirectUrl_From_FirstLeg,
out string _EmailAddress_From_FirstLeg,
out string _AzureADUniqueID_From_FirstLeg,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction)
{
_AuthorizationCode_From_FirstLeg = null;
_SSOStateUniqueID_QueryParameters = new BMemoryQueryParameters();
_SSOState = null;
_LocalRedirectUrl_From_FirstLeg = null;
_EmailAddress_From_FirstLeg = null;
_AzureADUniqueID_From_FirstLeg = null;
_FailureResponse = BWebResponse.InternalError("");
_ResponseContent = _ResponseContent.Trim();
//Handle error
if (_ResponseContent.StartsWith("error="))
{
var ErrorResponse = new JObject()
{
["result"] = "failure"
};
try
{
var ErrorFields = _ResponseContent.Split('&');
if (ErrorFields != null && ErrorFields.Length >= 2)
{
ErrorResponse["error"] = ErrorFields[0].Substring("error=".Length);
ErrorResponse["message"] = ErrorFields[1].Substring("error_description=".Length);
}
}
catch (Exception) { }
_FailureResponse = BWebResponse.Unauthorized(ErrorResponse.ToString());
return(false);
}
//Normal flow
var Splitted = _ResponseContent.Split('&');
if (Splitted == null || Splitted.Length < 3)
{
_FailureResponse = BWebResponse.BadRequest("Request body must contain all requested types. Split has failed.");
return(false);
}
string IDToken = null;
string StateField = null;
for (var i = 0; i < Splitted.Length; i++)
{
if (Splitted[i].StartsWith("id_token="))
{
IDToken = Splitted[i].Substring("id_token=".Length);
}
else if (Splitted[i].StartsWith("code="))
{
_AuthorizationCode_From_FirstLeg = Splitted[i].Substring("code=".Length);
}
else if (Splitted[i].StartsWith("state="))
{
StateField = WebUtility.UrlDecode(Splitted[i].Substring("state=".Length));
}
}
if (IDToken == null || _AuthorizationCode_From_FirstLeg == null || StateField == null)
{
_FailureResponse = BWebResponse.BadRequest("Request body must contain all requested types.");
return(false);
}
Splitted = StateField.Split('&');
if (Splitted == null || Splitted.Length < 3)
{
_FailureResponse = BWebResponse.BadRequest("State field must contain all mandatory entries. Split has failed.");
return(false);
}
bool bSSOStateUniqueID_QueryParameters_Set = false;
string TenantName = null;
for (var i = 0; i < Splitted.Length; i++)
{
if (Splitted[i].StartsWith("redirect_url="))
{
_LocalRedirectUrl_From_FirstLeg = WebUtility.UrlDecode(Splitted[i].Substring("redirect_url=".Length));
}
else if (Splitted[i].StartsWith("tenant="))
{
TenantName = Splitted[i].Substring("tenant=".Length);
}
else if (Splitted[i].StartsWith("state="))
{
_SSOStateUniqueID_QueryParameters = SSOStateMEntry.ID_SSO_STATE_MEMORY_SERVICE_KEY(Splitted[i].Substring("state=".Length));
bSSOStateUniqueID_QueryParameters_Set = true;
}
}
if (_LocalRedirectUrl_From_FirstLeg == null || TenantName == null || !bSSOStateUniqueID_QueryParameters_Set)
{
_FailureResponse = BWebResponse.BadRequest("State field must contain all mandatory entries.");
return(false);
}
var Serialized = MemoryService.GetKeyValue(_SSOStateUniqueID_QueryParameters, SSOStateMEntry.HASH_KEY, _ErrorMessageAction);
if (Serialized == null)
{
_FailureResponse = BWebResponse.Unauthorized("Login prompt session has expired. Please try again.");
return(false);
}
try
{
_SSOState = JsonConvert.DeserializeObject <SSOStateMEntry>(Serialized.AsString);
if (_SSOState == null)
{
throw new NullReferenceException();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Error: SSOLoginCallback->Parse_FirstLeg_Authentication_Content: Invalid session state. Message: " + e.Message + ", trace: " + e.StackTrace);
_FailureResponse = BWebResponse.InternalError("Invalid session state. Please try again.");
return(false);
}
if (_SSOState.Status != SSOStateMEntry.STATUS_AUTHENTICATING)
{
_FailureResponse = BWebResponse.Unauthorized("Invalid SSO state. Please try again.");
return(false);
}
if (TenantName != _SSOState.TenantName)
{
_FailureResponse = BWebResponse.Unauthorized("SSO state - request tenant mismatch. Please try again.");
return(false);
}
var JWTHandler = new JwtSecurityTokenHandler();
JwtSecurityToken Token = null;
try
{
Token = JWTHandler.ReadJwtToken(IDToken);
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Error: SSOLoginCallback->Parse_FirstLeg_Authentication_Content: Invalid JWT token. Token: " + IDToken + ", message: " + e.Message + ", trace: " + e.StackTrace);
_FailureResponse = BWebResponse.BadRequest("Invalid JWT token.");
return(false);
}
if (!Token.Payload.TryGetValue("email", out object EmailObject))
{
_FailureResponse = BWebResponse.BadRequest("JWT token does not contain email in the payload.");
return(false);
}
_EmailAddress_From_FirstLeg = ((string)EmailObject).ToLower();
if (!Token.Payload.TryGetValue("sub", out object AzureADUserUniqueIDObject))
{
_FailureResponse = BWebResponse.BadRequest("JWT token does not contain sub in the payload.");
return(false);
}
_AzureADUniqueID_From_FirstLeg = ((string)AzureADUserUniqueIDObject).ToLower();
return(true);
}
public static bool TryParsingRequestFor <T>(
HttpListenerContext _Context,
out JObject _SuccessResultJson,
bool _bDeserialize, out T _SuccessResultDeserialized,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_FailureResponse = BWebResponse.InternalError("");
_SuccessResultDeserialized = default;
_SuccessResultJson = null;
string[] MustHaveProperties;
string[] UpdatableProperties;
Dictionary <string, Func <JToken, bool> > UpdatablePropertiesValidityCheck;
if (typeof(T) == typeof(ModelDBEntry))
{
MustHaveProperties = ModelDBEntry.MustHaveProperties;
UpdatableProperties = ModelDBEntry.UpdatableProperties;
UpdatablePropertiesValidityCheck = ModelDBEntry.UpdatablePropertiesValidityCheck;
}
else if (typeof(T) == typeof(Revision))
{
MustHaveProperties = Revision.MustHaveProperties;
UpdatableProperties = Revision.UpdatableProperties;
UpdatablePropertiesValidityCheck = Revision.UpdatablePropertiesValidityCheck;
}
else if (typeof(T) == typeof(FileEntry))
{
MustHaveProperties = null;
UpdatableProperties = FileEntry.UpdatableProperties;
UpdatablePropertiesValidityCheck = FileEntry.UpdatablePropertiesValidityCheck;
}
else
{
throw new ArgumentException("Only ModelDBEntry and Revision are supported.");
}
using (var InputStream = _Context.Request.InputStream)
{
var NewObjectJson = new JObject();
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd());
var PropertiesList = new List <string>();
foreach (var Child in ParsedBody)
{
PropertiesList.Add(Child.Key);
}
if (MustHaveProperties != null)
{
foreach (var MustHaveProperty in MustHaveProperties)
{
if (!PropertiesList.Contains(MustHaveProperty))
{
_FailureResponse = BWebResponse.BadRequest("Request body must contain all necessary fields.");
return(false);
}
}
}
foreach (var Child in ParsedBody)
{
if (!UpdatablePropertiesValidityCheck[Child.Key](Child.Value))
{
_FailureResponse = BWebResponse.BadRequest("Given field " + Child.Key + " has invalid value.");
return(false);
}
if (UpdatableProperties.Contains(Child.Key))
{
NewObjectJson[Child.Key] = Child.Value;
}
else
{
_FailureResponse = BWebResponse.BadRequest("Unexpected field " + Child.Value.ToString());
return(false);
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace);
_FailureResponse = BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.");
return(false);
}
}
//For other elements to be created without any elements
_SuccessResultJson = NewObjectJson;
if (_bDeserialize)
{
_SuccessResultDeserialized = JsonConvert.DeserializeObject <T>(NewObjectJson.ToString());
}
}
return(true);
}
private bool AccessCheck(out BWebServiceResponse _FailureResponse, out bool _bSSOTokenRefreshed, out string _NewSSOTokenAfterRefresh, HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
_FailureResponse = new BWebServiceResponse();
_bSSOTokenRefreshed = false;
_NewSSOTokenAfterRefresh = "";
if (bAuthCheck)
{
//Check for authorization header
if (!BWebUtilities.DoesContextContainHeader(out List <string> Authorization, out string _, _Context, "authorization"))
{
_FailureResponse = BWebResponse.Unauthorized("Authorization header must be set.");
return(false);
}
var RequestObject = new JObject()
{
["forUrlPath"] = _Context.Request.RawUrl,
["requestMethod"] = _Context.Request.HttpMethod
};
if (BUtility.CheckAndGetFirstStringFromList(Authorization, out string _Authorization))
{
RequestObject["authorization"] = _Authorization;
}
else //Zero length
{
_FailureResponse = BWebResponse.Unauthorized("Authorization header must be set.");
return(false);
}
GetTracingService()?.On_FromGatewayToService_Sent(_Context, _ErrorMessageAction);
var Result = BWebServiceExtraUtilities.InterServicesRequest(new BWebServiceExtraUtilities.InterServicesRequestRequest()
{
DestinationServiceUrl = AuthServiceBaseUrl + "/auth/access_check",
RequestMethod = "POST",
ContentType = "application/json",
Content = new BStringOrStream(RequestObject.ToString()),
bWithAuthToken = true,
UseContextHeaders = _Context,
},
false,
_ErrorMessageAction);
GetTracingService()?.On_FromServiceToGateway_Received(_Context, _ErrorMessageAction);
if (!Result.bSuccess || Result.ResponseCode >= 400)
{
if (Result.ResponseCode == BWebResponse.Error_Unauthorized_Code ||
Result.ResponseCode == BWebResponse.Error_Forbidden_Code)
{
_FailureResponse = new BWebServiceResponse(Result.ResponseCode, Result.Content, Result.ContentType);
return(false);
}
_ErrorMessageAction?.Invoke("Access check internal call has failed: Response: " + Result.ResponseCode + " -> " + Result.Content.String + ", Request: " + RequestObject.ToString());
_FailureResponse = BWebResponse.InternalError("Internal access check call has failed.");
return(false);
}
var ResponseContent = Result.Content.ToString();
try
{
var Parsed = JObject.Parse(ResponseContent);
Authenticated_UserID = (string)Parsed["userId"];
Authenticated_UserName = (string)Parsed["userName"];
Authenticated_UserEmail = (string)Parsed["userEmail"];
Authenticated_AuthMethodKey = (string)Parsed["authMethodKey"];
_bSSOTokenRefreshed = (bool)Parsed["ssoTokenRefreshed"];
_NewSSOTokenAfterRefresh = (string)Parsed["newSSOTokenAfterRefresh"];
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("HandleRequest->AccessCheck: Error during content parse: " + ResponseContent + ", Message: " + e.Message + ", Trace: " + e.StackTrace);
_FailureResponse = BWebResponse.InternalError("Request has failed due to an internal api gateway error.");
return(false);
}
_Context.Request.Headers.Set("authorized-u-id", Authenticated_UserID);
_Context.Request.Headers.Set("authorized-u-name", Authenticated_UserName);
_Context.Request.Headers.Set("authorized-u-email", Authenticated_UserEmail);
_Context.Request.Headers.Set("authorized-u-auth-key", Authenticated_AuthMethodKey);
}
return(true);
}
private static bool GetProcessedFileNode_Internal(
ENodeType _FileType,
IBDatabaseServiceInterface _DatabaseService,
IBFileServiceInterface _FileService,
string _CadFileStorageBucketName,
string _ModelID,
int _RevisionIndex,
bool _bRootNodeRequested, uint _NodeStartIndex, uint _NodeSize,
out BWebServiceResponse _SuccessResponse,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_SuccessResponse = BWebResponse.InternalError("");
if (!TryGettingAllInfo(
_DatabaseService,
_ModelID,
_RevisionIndex,
out ModelDBEntry ModelObject,
out Revision RevisionObject,
out int _,
out _FailureResponse,
_ErrorMessageAction))
{
return(false);
}
if (RevisionObject.FileEntry.FileProcessStage != (int)Constants.EProcessStage.Uploaded_Processed)
{
_FailureResponse = BWebResponse.NotFound("Raw file has not been processed yet.");
return(false);
}
if (_bRootNodeRequested)
{
Convert.UniqueIDToStartIndexAndSize(RevisionObject.FileEntry.ProcessedFilesRootNodeID, out _NodeStartIndex, out _NodeSize);
if (_NodeStartIndex == 0 || _NodeSize == 0)
{
_FailureResponse = BWebResponse.InternalError("Invalid Root Node ID.");
return(false);
}
}
string RelativeFileUrl = null;
switch (_FileType)
{
case ENodeType.Hierarchy:
RelativeFileUrl = RevisionObject.FileEntry.HierarchyRAFRelativeUrl;
break;
case ENodeType.Geometry:
RelativeFileUrl = RevisionObject.FileEntry.GeometryRAFRelativeUrl;
break;
case ENodeType.Metadata:
RelativeFileUrl = RevisionObject.FileEntry.MetadataRAFRelativeUrl;
break;
}
Node RetrievedNode;
var Buffer = new byte[_NodeSize];
try
{
using (var MemStream = new MemoryStream((int)_NodeStartIndex))
{
var Destination = new BStringOrStream(MemStream, _NodeSize);
if (!_FileService.DownloadFile(_CadFileStorageBucketName, RelativeFileUrl, Destination, _ErrorMessageAction, _NodeStartIndex, _NodeSize))
{
_ErrorMessageAction?.Invoke("DownloadFile has failed in GetProcessedFileNode_Internal. ModelID: " + _ModelID + ", RevisionIndex: " + _RevisionIndex + ", NodeStartIndex: " + _NodeStartIndex + ", NodeSize: " + _NodeSize);
_FailureResponse = BWebResponse.NotFound("Given Node ID does not exist.");
return(false);
}
MemStream.Seek(0, SeekOrigin.Begin);
if (MemStream.Read(Buffer, 0, (int)_NodeSize) < (int)_NodeSize)
{
_FailureResponse = BWebResponse.InternalError("Stream read operation has failed.");
return(false);
}
Convert.BufferToNode(out RetrievedNode, _FileType, Buffer, 0);
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("File random access/stream operations have failed. ModelID: " + _ModelID + ", RevisionIndex: " + _RevisionIndex + ", NodeStartIndex: " + _NodeStartIndex + ", NodeSize: " + _NodeSize + ", Message: " + e.Message + ", Trace: " + e.StackTrace);
_FailureResponse = BWebResponse.NotFound("Given Node ID does not exist.");
return(false);
}
if (RetrievedNode == null)
{
_FailureResponse = BWebResponse.InternalError("File node parse operation has failed.");
return(false);
}
_SuccessResponse = BWebResponse.StatusOK("Node has been located.", new JObject()
{
["node"] = JObject.Parse(JsonConvert.SerializeObject(RetrievedNode))
});
return(true);
}
private static bool GetProcessedFile_Internal(
ENodeType _FileType,
IBDatabaseServiceInterface _DatabaseService,
IBFileServiceInterface _FileService,
string _CadFileStorageBucketName,
string _ModelID,
int _RevisionIndex,
out BWebServiceResponse _SuccessResponse,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_SuccessResponse = BWebResponse.InternalError("");
if (!TryGettingAllInfo(
_DatabaseService,
_ModelID,
_RevisionIndex,
out ModelDBEntry _,
out Revision RevisionObject,
out int _,
out _FailureResponse,
_ErrorMessageAction))
{
return(false);
}
if (RevisionObject.FileEntry.FileProcessStage != (int)Constants.EProcessStage.Uploaded_Processed)
{
_FailureResponse = BWebResponse.NotFound("Raw file has not been processed yet.");
return(false);
}
string RelativeFileUrl = null;
switch (_FileType)
{
case ENodeType.Hierarchy:
RelativeFileUrl = RevisionObject.FileEntry.HierarchyCFRelativeUrl;
break;
case ENodeType.Geometry:
RelativeFileUrl = RevisionObject.FileEntry.GeometryCFRelativeUrl;
break;
case ENodeType.Metadata:
RelativeFileUrl = RevisionObject.FileEntry.MetadataCFRelativeUrl;
break;
}
if (!_FileService.CreateSignedURLForDownload(
out string DownloadUrl,
_CadFileStorageBucketName,
RelativeFileUrl,
FileEntry.EXPIRY_MINUTES,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Signed url generation has failed.");
return(false);
}
_SuccessResponse = BWebResponse.StatusOK("File has been located.", new JObject()
{
[FileEntry.FILE_DOWNLOAD_URL_PROPERTY] = DownloadUrl,
[FileEntry.FILE_DOWNLOAD_UPLOAD_EXPIRY_MINUTES_PROPERTY] = FileEntry.EXPIRY_MINUTES
});
return(true);
}
private static bool GetProcessedFile_Internal(
EProcessedFileType _FileType,
IBDatabaseServiceInterface _DatabaseService,
IBFileServiceInterface _FileService,
string _CadFileStorageBucketName,
string _ModelID,
int _RevisionIndex,
out BWebServiceResponse _SuccessResponse,
out BWebServiceResponse _FailureResponse,
string _GeometryId = null,
Action <string> _ErrorMessageAction = null)
{
_SuccessResponse = BWebResponse.InternalError("");
if (!TryGettingAllInfo(
_DatabaseService,
_ModelID,
_RevisionIndex,
out ModelDBEntry _,
out Revision RevisionObject,
out int _,
out _FailureResponse,
_ErrorMessageAction))
{
return(false);
}
if (RevisionObject.FileEntry.FileProcessStage != (int)Constants.EProcessStage.Uploaded_Processed)
{
_FailureResponse = BWebResponse.NotFound("Raw file has not been processed yet.");
return(false);
}
string RelativeFileUrl = null;
switch (_FileType)
{
case EProcessedFileType.HIERARCHY_CF:
RelativeFileUrl = RevisionObject.FileEntry.HierarchyCFRelativeUrl;
break;
case EProcessedFileType.HIERARCHY_RAF:
RelativeFileUrl = RevisionObject.FileEntry.HierarchyRAFRelativeUrl;
break;
case EProcessedFileType.METADATA_CF:
RelativeFileUrl = RevisionObject.FileEntry.MetadataCFRelativeUrl;
break;
case EProcessedFileType.METADATA_RAF:
RelativeFileUrl = RevisionObject.FileEntry.MetadataRAFRelativeUrl;
break;
case EProcessedFileType.GEOMETRY_CF:
RelativeFileUrl = RevisionObject.FileEntry.GeometryCFRelativeUrl;
break;
case EProcessedFileType.GEOMETRY_RAF:
RelativeFileUrl = RevisionObject.FileEntry.GeometryRAFRelativeUrl;
break;
case EProcessedFileType.UNREAL_HGM:
RelativeFileUrl = RevisionObject.FileEntry.UnrealHGMRelativeUrl;
break;
case EProcessedFileType.UNREAL_HG:
RelativeFileUrl = RevisionObject.FileEntry.UnrealHGRelativeUrl;
break;
case EProcessedFileType.UNREAL_H:
RelativeFileUrl = RevisionObject.FileEntry.UnrealHRelativeUrl;
break;
case EProcessedFileType.UNREAL_G:
if (_GeometryId == null)
{
_ErrorMessageAction?.Invoke("GeometryId was not set when tried to retrieve UnrealGeometry file (u_g)");
_FailureResponse = BWebResponse.InternalError("GeometryId was not provided.");
}
RelativeFileUrl = $"{RevisionObject.FileEntry.UnrealGRelativeUrlBasePath}{_GeometryId}.{Constants.ProcessedFileType_Extension_Map[EProcessedFileType.UNREAL_G]}";
break;
}
if (!_FileService.CreateSignedURLForDownload(
out string DownloadUrl,
_CadFileStorageBucketName,
RelativeFileUrl,
FileEntry.EXPIRY_MINUTES,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Signed url generation has failed.");
return(false);
}
_SuccessResponse = BWebResponse.StatusOK("File has been located.", new JObject()
{
[FileEntry.FILE_DOWNLOAD_URL_PROPERTY] = DownloadUrl,
[FileEntry.FILE_DOWNLOAD_UPLOAD_EXPIRY_MINUTES_PROPERTY] = FileEntry.EXPIRY_MINUTES
});
return(true);
}
public static bool FetchBaseAccessRights_ByUserID(
IBDatabaseServiceInterface _DatabaseService,
IBMemoryServiceInterface _MemoryService,
string _UserID,
out List <AccessScope> _AccessScopes,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_AccessScopes = null;
_FailureResponse = new BWebServiceResponse();
var InMemoryResult = _MemoryService.GetKeyValue(CommonData.MemoryQueryParameters, UserBaseAccessMEntry.M_KEY_NAME_USER_ID + _UserID, _ErrorMessageAction);
if (InMemoryResult != null)
{
try
{
_AccessScopes = JsonConvert.DeserializeObject <UserBaseAccessMEntry>(InMemoryResult.AsString).BaseAccessScope;
return(true);
}
catch (Exception) { }
}
if (!_DatabaseService.GetItem(
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
new BPrimitiveType(_UserID),
UserDBEntry.Properties,
out JObject UserObject,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Database fetch-user-info operation has failed.");
return(false);
}
if (UserObject == null)
{
_FailureResponse = BWebResponse.NotFound("User does not exist.");
return(false);
}
_AccessScopes = new List <AccessScope>();
if (UserObject.ContainsKey(UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY))
{
var BaseAccessScopeAsArray = (JArray)UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY];
foreach (JObject ScopeObject in BaseAccessScopeAsArray)
{
_AccessScopes.Add(JsonConvert.DeserializeObject <AccessScope>(ScopeObject.ToString()));
}
}
_MemoryService.SetKeyValue(CommonData.MemoryQueryParameters, new Tuple <string, BPrimitiveType>[]
{
new Tuple <string, BPrimitiveType>(
UserBaseAccessMEntry.M_KEY_NAME_USER_ID + _UserID,
new BPrimitiveType(JsonConvert.SerializeObject(new UserBaseAccessMEntry()
{
BaseAccessScope = _AccessScopes
})))
}, _ErrorMessageAction);
return(true);
}
public static bool GenerateNonExistentUniqueID(
WebServiceBaseTimeoutable _Request,
IBDatabaseServiceInterface _DatabaseService,
string _TableName,
string _TableKeyName,
string[] _TableEntryMustHaveProperties,
EGetClearance _GetClearance,
out string _GeneratedUniqueID,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_GeneratedUniqueID = null;
_FailureResponse = BWebResponse.InternalError("");
int ExistenceTrial = 0;
while (_GeneratedUniqueID == null && ExistenceTrial < 3)
{
if (!BUtility.CalculateStringMD5(BUtility.RandomString(32, false), out _GeneratedUniqueID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Hashing operation has failed.");
return(false);
}
if (_GetClearance == EGetClearance.Yes && !Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(_Request.InnerProcessor, _TableName, _GeneratedUniqueID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Atomic operation control has failed.");
return(false);
}
if (!_DatabaseService.GetItem(
_TableName,
_TableKeyName,
new BPrimitiveType(_GeneratedUniqueID),
_TableEntryMustHaveProperties,
out JObject ExistenceCheck,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Database existence check operation has failed.");
return(false);
}
if (ExistenceCheck != null)
{
if (_GetClearance == EGetClearance.Yes)
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(_Request.InnerProcessor, _TableName, _GeneratedUniqueID, _ErrorMessageAction);
}
_GeneratedUniqueID = null;
ExistenceTrial++;
}
else
{
break;
}
}
if (_GeneratedUniqueID == null)
{
_FailureResponse = BWebResponse.InternalError("Unique model ID generation operation has failed.");
return(false);
}
return(true);
}
