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); }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { AuthorizedUser = ServiceUtilities.Common.Methods.GetAuthorizedRequester(_Context, _ErrorMessageAction); if (!AuthorizedUser.bParseSuccessful) { return(BWebResponse.InternalError(AuthorizedUser.ParseErrorMessage)); } if (_Context.Request.HttpMethod != "GET") { _ErrorMessageAction?.Invoke("GetModelsBy_MetadataKeyValueUserPair: GET method is accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("GET method is accepted. But received request method: " + _Context.Request.HttpMethod)); } var UserID = RestfulUrlParameters[RestfulUrlParameter_UserID]; var MetadataKey = WebUtility.UrlDecode(RestfulUrlParameters[RestfulUrlParameter_MetadataKey]); if (!DatabaseService.GetItem( AttributeKUPairToOwnerDBEntry.TABLE(), AttributeKUPairToOwnerDBEntry.KEY_NAME, Controller_AttributeTables.MakeKey(MetadataKey, UserID), new string[] { AttributeKeyDBEntryBase.METADATA_LOCATOR_PROPERTY }, out JObject Result, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database query has failed.")); } if (Result == null || !Result.ContainsKey(AttributeKeyDBEntryBase.METADATA_LOCATOR_PROPERTY) || Result[AttributeKeyDBEntryBase.METADATA_LOCATOR_PROPERTY].Type != JTokenType.Array) { return(BWebResponse.NotFound("Entry not found.")); } var AsArray = (JArray)Result[AttributeKeyDBEntryBase.METADATA_LOCATOR_PROPERTY]; for (int i = 0; i < AsArray.Count; i++) { var AsStr = (string)AsArray[i]; if (AsStr != null) { if (AsStr.StartsWith(Controller_AttributeTables.MODEL_METADATA_PREFIX)) { AsStr = AsStr.Substring(Controller_AttributeTables.MODEL_METADATA_PREFIX.Length); } else if (AsStr.StartsWith(Controller_AttributeTables.REVISION_METADATA_PREFIX)) { AsStr = AsStr.Substring(Controller_AttributeTables.REVISION_METADATA_PREFIX.Length); AsStr = AsStr.Replace(Controller_AttributeTables.REVISION_METADATA_MRV_DELIMITER, "->"); } AsArray[i] = AsStr; } } return(BWebResponse.StatusOK("Model(s) have been located.", new JObject() { [AttributeKeyDBEntryBase.METADATA_LOCATOR_PROPERTY] = AsArray })); }
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 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); }
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); }
private BWebServiceResponse UpdateModelInfo(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { if (!CommonMethods.TryParsingRequestFor( _Context, out JObject UpdateFieldsModelEntry, false, out ModelDBEntry _, out BWebServiceResponse FailureResponse, _ErrorMessageAction)) { return(FailureResponse); } if (!CommonMethods.TryGettingModelInfo( DatabaseService, RequestedModelID, out JObject _, true, out ModelDBEntry Model, out FailureResponse, _ErrorMessageAction)) { return(FailureResponse); } //If there is a change in the model name bool bGetClearanceForModelName_New = false; bool bGetClearanceForModelName_Old = false; string ModelUniqueName_New = null; string ModelUniqueName_Old = null; try { if (UpdateFieldsModelEntry.ContainsKey(ModelDBEntry.MODEL_UNIQUE_NAME_PROPERTY) && Model.ModelName != (string)UpdateFieldsModelEntry[ModelDBEntry.MODEL_UNIQUE_NAME_PROPERTY]) { ModelUniqueName_New = (string)UpdateFieldsModelEntry[ModelDBEntry.MODEL_UNIQUE_NAME_PROPERTY]; if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + ModelUniqueName_New, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bGetClearanceForModelName_New = true; ModelUniqueName_Old = Model.ModelName; if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + ModelUniqueName_Old, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bGetClearanceForModelName_Old = true; //Put the new one if (!DatabaseService.UpdateItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(ModelUniqueName_New), new JObject() { [ModelDBEntry.KEY_NAME_MODEL_ID] = RequestedModelID }, out JObject _, EBReturnItemBehaviour.DoNotReturn, DatabaseService.BuildAttributeNotExistCondition(UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME), _ErrorMessageAction)) { if (!DatabaseService.GetItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(ModelUniqueName_New), UniqueFileFieldsDBEntry.Properties, out JObject ModelIDResponse, _ErrorMessageAction) || !ModelIDResponse.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID)) { return(BWebResponse.InternalError("Model ID could not be retrieved upon conflict.")); } var Result = JObject.Parse(BWebResponse.Error_Conflict_String("Attribute " + UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + " must be globally unique.")); Result[ModelDBEntry.KEY_NAME_MODEL_ID] = (string)ModelIDResponse[ModelDBEntry.KEY_NAME_MODEL_ID]; return(new BWebServiceResponse( BWebResponse.Error_Conflict_Code, new BStringOrStream(Result.ToString()), BWebResponse.Error_Conflict_ContentType)); } //Delete the old one Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(ModelUniqueName_Old)); } var OldModelMetadataSet = Model.ModelMetadata; Model.Merge(UpdateFieldsModelEntry); var NewModelMetadataSet = Model.ModelMetadata; if (OldModelMetadataSet != NewModelMetadataSet) { var MetaLocator = Controller_AttributeTables.MetadataLocator.ItIsModelMetadata(RequestedModelID); //First remove all metadata sets Controller_AttributeTables.Get().AddRemoveMetadataSets_AttributesTables( InnerDeliveryEnsurerUserProcessor, Model.ModelOwnerUserID, MetaLocator, OldModelMetadataSet, Controller_AttributeTables.EAddRemove.Remove, Controller_AttributeTables.EKillProcedureIfGetClearanceFails.No, out BWebServiceResponse _, _ErrorMessageAction); //Then add new metadata sets Controller_AttributeTables.Get().AddRemoveMetadataSets_AttributesTables( InnerDeliveryEnsurerUserProcessor, Model.ModelOwnerUserID, MetaLocator, NewModelMetadataSet, Controller_AttributeTables.EAddRemove.Add, Controller_AttributeTables.EKillProcedureIfGetClearanceFails.No, out BWebServiceResponse _, _ErrorMessageAction); } Model.MRVLastUpdateTime = CommonMethods.GetTimeAsCreationTime(); Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelDBEntry.KEY_NAME_MODEL_ID, new BPrimitiveType(RequestedModelID), JObject.Parse(JsonConvert.SerializeObject(Model))); Controller_ModelActions.Get().BroadcastModelAction(new Action_ModelUpdated ( RequestedModelID, Model.ModelOwnerUserID, Model.ModelSharedWithUserIDs, AuthorizedUser.UserID, UpdateFieldsModelEntry ), _ErrorMessageAction); return(BWebResponse.StatusOK("Model has been successfully updated.")); } finally { if (bGetClearanceForModelName_New) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + ModelUniqueName_New, _ErrorMessageAction); } if (bGetClearanceForModelName_Old) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + ModelUniqueName_Old, _ErrorMessageAction); } } }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { _ErrorMessageAction?.Invoke("Trying to get Optimizer Env Vars"); if (_Context.Request.HttpMethod != "GET") { _ErrorMessageAction?.Invoke("Wrong type"); return(BWebResponse.BadRequest($"This service does not accept requests of type : {_Context.Request.HttpMethod}")); } string Url = _Context.Request.RawUrl; int CopyStart = Url.LastIndexOf('/') + 1; string Podname = Url.Substring(CopyStart).TrimEnd('/'); BatchProcessingCreationService.Instance.GetBucketAndFile(Podname, out string _Bucket, out string _Filename); if (!string.IsNullOrWhiteSpace(_Bucket) && !string.IsNullOrWhiteSpace(_Filename)) { string NewConversionID_FromRelativeUrl_UrlEncoded = WebUtility.UrlEncode(_Filename); bool CanProceed = false; bool ProcessError = false; if (DatabaseService.GetItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(NewConversionID_FromRelativeUrl_UrlEncoded), FileConversionDBEntry.Properties, out JObject ConversionObject )) { if (ConversionObject != null && ConversionObject.ContainsKey("conversionStatus")) { EInternalProcessStage ExistingStatus = (EInternalProcessStage)(int)ConversionObject["conversionStatus"]; if (ExistingStatus == EInternalProcessStage.ProcessComplete) { CanProceed = true; } else if (ExistingStatus == EInternalProcessStage.ProcessFailed) { ProcessError = true; } } } else { ProcessError = true; } if (CanProceed) { Dictionary <string, string> EnvVars = BatchProcessingCreationService.Instance.GetOptimizerEnvVars(_Bucket, _Filename, Podname, _ErrorMessageAction); if (EnvVars == null) { _ErrorMessageAction?.Invoke("EnvVars null"); return(BWebResponse.InternalError("An error occured trying to generate optimizer parameters")); } return(BWebResponse.StatusOK("success", new JObject() { ["uploadRequestUrl"] = EnvVars["CAD_PROCESS_UPLOAD_REQUEST_URL"], ["downloadHierarchyCfUrl"] = EnvVars["DOWNLOAD_HIERARCHY_CF"], ["downloadGeometryCfUrl"] = EnvVars["DOWNLOAD_GEOMETRY_CF"], ["downloadMetadataCfUrl"] = EnvVars["DOWNLOAD_METADATA_CF"] })); } else if (ProcessError) { _ErrorMessageAction?.Invoke("Cad process Failed"); return(BWebResponse.InternalError("Pixyz process has failed")); } else { _ErrorMessageAction?.Invoke("Not found"); return(BWebResponse.NotFound("Cad process has not completed yet")); } } else { _ErrorMessageAction?.Invoke("General failure"); return(BWebResponse.InternalError("An error occured trying to retreive pod details")); } }
private bool ModelSharingChanged(Action_ModelSharedWithUserIdsChanged _Action, Action <string> _ErrorMessageAction = null) { var OldHasStar = _Action.OldModelSharedWithUserIDs.Contains("*"); var NewHasStar = _Action.ModelSharedWithUserIDs.Contains("*"); //Check if old and new both have * if (OldHasStar && NewHasStar) { return(true); } var UsersListJObject = new List <JObject>(); if (OldHasStar || NewHasStar) { if (!DatabaseService.ScanTable(UserDBEntry.DBSERVICE_USERS_TABLE(), out UsersListJObject, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("InternalCalls->PubSub_To_AuthService->ModelSharingChanged: ScanTable has failed."); return(false); //Internal error, return error for retrial. } if (UsersListJObject.Count == 0) { return(true); } } var ToBeAddedUsers = new List <string>(); var ToBeRemovedUsers = new List <string>(); //Check if old contains * but not the new if (OldHasStar && !NewHasStar) { foreach (var UserObject in UsersListJObject) { if (UserObject != null && UserObject.ContainsKey(UserDBEntry.KEY_NAME_USER_ID)) { var UserId = (string)UserObject[UserDBEntry.KEY_NAME_USER_ID]; if (!_Action.ModelSharedWithUserIDs.Contains(UserId)) { ToBeRemovedUsers.Add(UserId); } else { ToBeAddedUsers.Add(UserId); } } } } //Check if new contains * but not the old else if (!OldHasStar && NewHasStar) { foreach (var UserObject in UsersListJObject) { if (UserObject != null && UserObject.ContainsKey(UserDBEntry.KEY_NAME_USER_ID)) { ToBeAddedUsers.Add((string)UserObject[UserDBEntry.KEY_NAME_USER_ID]); } } } //None has star else { var AlreadyFetchedUserObjects = new Dictionary <string, UserDBEntry>(); foreach (var OldUserId in _Action.OldModelSharedWithUserIDs) { if (!_Action.ModelSharedWithUserIDs.Contains(OldUserId)) { //Just to check existence we only get the id as property if (!DatabaseService.GetItem(UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(OldUserId), new string[] { UserDBEntry.KEY_NAME_USER_ID }, out JObject UserObject, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("InternalCalls->PubSub_To_AuthService->ModelSharingChanged: GetItem for " + UserDBEntry.KEY_NAME_USER_ID + ": " + OldUserId + " has failed."); return(false); //Internal error, return error for retrial. } if (UserObject == null) { continue; } ToBeRemovedUsers.Add(OldUserId); } } foreach (var NewUserId in _Action.ModelSharedWithUserIDs) { if (!_Action.OldModelSharedWithUserIDs.Contains(NewUserId)) { if (!ToBeRemovedUsers.Remove(NewUserId)) { //Just to check existence we only get the id as property if (!DatabaseService.GetItem(UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(NewUserId), new string[] { UserDBEntry.KEY_NAME_USER_ID }, out JObject UserObject, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("InternalCalls->PubSub_To_AuthService->ModelSharingChanged: GetItem for " + UserDBEntry.KEY_NAME_USER_ID + ": " + NewUserId + " has failed."); return(false); //Internal error, return error for retrial. } if (UserObject == null) { continue; } } ToBeAddedUsers.Add(NewUserId); } } } //Do not play with owner's rights ToBeAddedUsers.Remove(_Action.UserID); ToBeRemovedUsers.Remove(_Action.UserID); //No changes need to be made if (ToBeAddedUsers.Count == 0 && ToBeRemovedUsers.Count == 0) { return(true); } var PathsRegex = new Tuple <string, List <string> >[] { new Tuple <string, List <string> >("/3d/models/" + _Action.ModelID + "*", new List <string>() { "GET" }), //Only view access new Tuple <string, List <string> >("/3d/models/" + _Action.ModelID + "/remove_sharing_from/user_id/{shareeUserId}", new List <string>() { "DELETE" }) }; if (!UpdateUsersSharedModelsFields(ToBeAddedUsers, _Action.ModelID, Controller_Rights_Internal.EChangeUserRightsForModelType.Add, _ErrorMessageAction)) { return(false); } if (!UpdateUsersSharedModelsFields(ToBeRemovedUsers, _Action.ModelID, Controller_Rights_Internal.EChangeUserRightsForModelType.Delete, _ErrorMessageAction)) { return(false); } if (!UpdateRightsForUsersUponChangeOnSharing(ToBeAddedUsers, PathsRegex, Controller_Rights_Internal.EChangeUserRightsForModelType.Add, _ErrorMessageAction)) { return(false); } if (!UpdateRightsForUsersUponChangeOnSharing(ToBeRemovedUsers, PathsRegex, Controller_Rights_Internal.EChangeUserRightsForModelType.Delete, _ErrorMessageAction)) { return(false); } return(true); }
private BWebServiceResponse AddUpdateBaseRightsForUser(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { var NewBaseScopeListFromRequest = new List <AccessScope>(); using (var InputStream = _Context.Request.InputStream) { using (var ResponseReader = new StreamReader(InputStream)) { try { var NewScopes = JArray.Parse(ResponseReader.ReadToEnd()); foreach (JObject NewScope in NewScopes) { var ConvertedScope = JsonConvert.DeserializeObject <AccessScope>(NewScope.ToString()); for (int i = ConvertedScope.AccessRights.Count - 1; i >= 0; i--) { ConvertedScope.AccessRights[i] = ConvertedScope.AccessRights[i].ToUpper(); if (!AccessScopeLibrary.ACCESS_RIGHTS.Contains(ConvertedScope.AccessRights[i])) { ConvertedScope.AccessRights.RemoveAt(i); } } if (ConvertedScope.AccessRights.Count > 0) { ConvertedScope.AccessRights = ConvertedScope.AccessRights.Distinct().ToList(); NewBaseScopeListFromRequest.Add(ConvertedScope); } } } catch (Exception e) { _ErrorMessageAction?.Invoke("User_AddListBaseRights_ForUser->AddUpdateBaseRightsForUser: Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } if (NewBaseScopeListFromRequest.Count == 0) { return(BWebResponse.BadRequest("Request does not contain any valid base scope. Access rights can be: " + AccessScopeLibrary.GetPossibleAccessRightsText())); } var UserKey = new BPrimitiveType(RequestedUserID); if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-user-info operation has failed.")); } if (UserObject == null) { return(BWebResponse.NotFound("User does not exist.")); } var NewBaseAccessScopeAsJArray = new JArray(); var NewBaseAccessScopeAsList = new List <AccessScope>(); bool bUpdateOccurredForUserEntry = false; if (UserObject.ContainsKey(UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY)) { var BaseAccessScopeAsArray = (JArray)UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY]; foreach (var NewScope in NewBaseScopeListFromRequest) { bool bNewScopeFoundInExisting = false; NewScope.AccessRights.Sort(); foreach (JObject ExistingScopeObject in BaseAccessScopeAsArray) { bool bChangeOccurredForScope = false; var ExistingScope = JsonConvert.DeserializeObject <AccessScope>(ExistingScopeObject.ToString()); ExistingScope.AccessRights.Sort(); if (!bNewScopeFoundInExisting && ExistingScope.WildcardPath == NewScope.WildcardPath) { bNewScopeFoundInExisting = true; if (NewScope.AccessRights.Count != ExistingScope.AccessRights.Count) { bUpdateOccurredForUserEntry = true; NewBaseAccessScopeAsList.Add(NewScope); NewBaseAccessScopeAsJArray.Add(JObject.Parse(JsonConvert.SerializeObject(NewScope))); break; } else { bool bLocalChangeExists = false; for (int i = 0; i < NewScope.AccessRights.Count; i++) { if (NewScope.AccessRights[i] != ExistingScope.AccessRights[i]) { bLocalChangeExists = true; break; } } if (bLocalChangeExists) { bUpdateOccurredForUserEntry = true; bChangeOccurredForScope = true; NewBaseAccessScopeAsList.Add(NewScope); NewBaseAccessScopeAsJArray.Add(JObject.Parse(JsonConvert.SerializeObject(NewScope))); } } } if (!bChangeOccurredForScope) { NewBaseAccessScopeAsList.Add(ExistingScope); NewBaseAccessScopeAsJArray.Add(ExistingScopeObject); } } if (!bNewScopeFoundInExisting) { NewBaseAccessScopeAsList.Add(NewScope); NewBaseAccessScopeAsJArray.Add(JObject.Parse(JsonConvert.SerializeObject(NewScope))); bUpdateOccurredForUserEntry = true; } } } if (bUpdateOccurredForUserEntry) { UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY] = NewBaseAccessScopeAsJArray; MemoryService.SetKeyValue(CommonData.MemoryQueryParameters, new Tuple <string, BPrimitiveType>[] { new Tuple <string, BPrimitiveType>( UserBaseAccessMEntry.M_KEY_NAME_USER_ID + RequestedUserID, new BPrimitiveType(JsonConvert.SerializeObject(new UserBaseAccessMEntry() { BaseAccessScope = NewBaseAccessScopeAsList }))) }, _ErrorMessageAction); Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserObject); } return(BWebResponse.StatusCreated("New base rights have been added.")); }
private bool CreateUser(out string _UserID, string _EmailWithoutPostfix, Action <string> _ErrorMessageAction, string _OptionalName = null) { _UserID = null; var Endpoint = "http://localhost:" + LocalServerPort + "/auth/users"; 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("internal-call-secret", CommonData.INTERNAL_CALL_PRIVATE_KEY); Client.DefaultRequestHeaders.TryAddWithoutValidation("do-not-get-db-clearance", "false"); try { using var RequestContent = new StringContent(new JObject() { [UserDBEntry.USER_EMAIL_PROPERTY] = _EmailWithoutPostfix, [UserDBEntry.USER_NAME_PROPERTY] = _OptionalName != null ? _OptionalName : _EmailWithoutPostfix }.ToString(), Encoding.UTF8, "application/json"); using var RequestTask = Client.PutAsync(Endpoint, RequestContent); RequestTask.Wait(); using var Response = RequestTask.Result; using var ResponseContent = Response.Content; using var ReadResponseTask = ResponseContent.ReadAsStringAsync(); ReadResponseTask.Wait(); var ResponseString = ReadResponseTask.Result; if (!Response.IsSuccessStatusCode) { if ((int)Response.StatusCode == BWebResponse.Error_Conflict_Code) { if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(_EmailWithoutPostfix), UniqueUserFieldsDBEntry.Properties, out JObject _ExistenceCheck, _ErrorMessageAction)) { return(false); } _UserID = (string)_ExistenceCheck[UserDBEntry.KEY_NAME_USER_ID]; return(true); } _ErrorMessageAction?.Invoke("Error: CreateTestUser->CreateUser: Request returned error. Endpoint: " + Endpoint + ", code: " + Response.StatusCode + ", message: " + ResponseString); return(false); } _UserID = (string)JObject.Parse(ResponseString)[UserDBEntry.KEY_NAME_USER_ID]; } catch (Exception e) { if (e.InnerException != null && e.InnerException != e) { _ErrorMessageAction?.Invoke("Error: CreateTestUser->CreateUser->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace); } if (e is AggregateException) { foreach (var Inner in (e as AggregateException).InnerExceptions) { _ErrorMessageAction?.Invoke("Error: CreateTestUser->CreateUser->Aggregate->Inner: " + Inner.Message + ", Trace: " + Inner.StackTrace); } } _ErrorMessageAction?.Invoke("Error: CreateTestUser->CreateUser: Request failed. Endpoint: " + Endpoint + ", message: " + e.Message + ", trace: " + e.StackTrace); return(false); } return(true); }
protected override BWebServiceResponse Process(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null) { if (_Context.Request.HttpMethod != "POST") { _ErrorMessageAction?.Invoke("GetUserIDsFromEmailsRequest: POST method is accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("POST method is accepted. But received request method: " + _Context.Request.HttpMethod)); } string RequestPayload = null; JObject ParsedBody; using (var InputStream = _Context.Request.InputStream) { using var ResponseReader = new StreamReader(InputStream); try { RequestPayload = ResponseReader.ReadToEnd(); ParsedBody = JObject.Parse(RequestPayload); } catch (Exception e) { _ErrorMessageAction?.Invoke("GetUserIDsFromEmailsRequest-> Malformed request body. Body content: " + RequestPayload + ", Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } if (!ParsedBody.ContainsKey("emailAddresses") || ParsedBody["emailAddresses"].Type != JTokenType.Array) { return(BWebResponse.BadRequest("Invalid request body.")); } var AsJArray = (JArray)ParsedBody["emailAddresses"]; var EmailAddresses = new List <string>(); foreach (var Token in AsJArray) { if (Token.Type != JTokenType.String) { return(BWebResponse.BadRequest("Invalid request body.")); } var EmailAddress = ((string)Token).ToLower(); if (!EmailAddresses.Contains(EmailAddress)) { EmailAddresses.Add(EmailAddress); } } if (EmailAddresses.Count == 0) { return(BWebResponse.BadRequest("Empty emailAddresses field.")); } var ResponseObject = new JObject(); foreach (var Email in EmailAddresses) { if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(Email), UniqueUserFieldsDBEntry.Properties, out JObject ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-uniqueness-info operation has failed.")); } if (ExistenceCheck == null) { return(BWebResponse.NotFound("A user with e-mail " + Email + " does not exist.")); } ResponseObject[Email] = (string)ExistenceCheck[UserDBEntry.KEY_NAME_USER_ID]; } return(BWebResponse.StatusOK("OK.", new JObject() { ["map"] = ResponseObject })); }
private BWebServiceResponse CreateModel(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { if (!CommonMethods.TryParsingRequestFor( _Context, out JObject _, true, out ModelDBEntry NewModelObject, out BWebServiceResponse FailureResponse, _ErrorMessageAction)) { return(FailureResponse); } NewModelObject.ModelOwnerUserID = AuthorizedUser.UserID; if (!CommonMethods.GenerateNonExistentUniqueID( this, DatabaseService, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelDBEntry.KEY_NAME_MODEL_ID, ModelDBEntry.MustHaveProperties, CommonMethods.EGetClearance.Yes, out string ModelID, out BWebServiceResponse _FailureResponse, _ErrorMessageAction)) { return(_FailureResponse); } bool bGetClearanceForModelName = false; try { if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + NewModelObject.ModelName, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bGetClearanceForModelName = true; if (!DatabaseService.UpdateItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(NewModelObject.ModelName), new JObject() { [ModelDBEntry.KEY_NAME_MODEL_ID] = ModelID }, out JObject _, EBReturnItemBehaviour.DoNotReturn, DatabaseService.BuildAttributeNotExistCondition(UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME), _ErrorMessageAction)) { if (!DatabaseService.GetItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(NewModelObject.ModelName), UniqueFileFieldsDBEntry.Properties, out JObject ModelIDResponse, _ErrorMessageAction) || !ModelIDResponse.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID)) { return(BWebResponse.InternalError("Model ID could not be retrieved upon conflict.")); } var Result = JObject.Parse(BWebResponse.Error_Conflict_String("Attribute " + UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + " must be globally unique.")); Result[ModelDBEntry.KEY_NAME_MODEL_ID] = (string)ModelIDResponse[ModelDBEntry.KEY_NAME_MODEL_ID]; return(new BWebServiceResponse( BWebResponse.Error_Conflict_Code, new BStringOrStream(Result.ToString()), BWebResponse.Error_Conflict_ContentType)); } if (!Controller_AttributeTables.Get().AddRemoveMetadataSets_AttributesTables( InnerDeliveryEnsurerUserProcessor, NewModelObject.ModelOwnerUserID, Controller_AttributeTables.MetadataLocator.ItIsModelMetadata(ModelID), NewModelObject.ModelMetadata, Controller_AttributeTables.EAddRemove.Add, Controller_AttributeTables.EKillProcedureIfGetClearanceFails.Yes, out _FailureResponse, _ErrorMessageAction)) { return(_FailureResponse); } NewModelObject.CreationTime = CommonMethods.GetTimeAsCreationTime(); NewModelObject.MRVLastUpdateTime = NewModelObject.CreationTime; Controller_DeliveryEnsurer.Get().DB_PutItem_FireAndForget( _Context, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelDBEntry.KEY_NAME_MODEL_ID, new BPrimitiveType(ModelID), JObject.Parse(JsonConvert.SerializeObject(NewModelObject))); Controller_ModelActions.Get().BroadcastModelAction(new Action_ModelCreated ( ModelID, AuthorizedUser.UserID, new List <string>(), AuthorizedUser.AuthMethodKey ), _ErrorMessageAction); return(BWebResponse.StatusCreated("Model has been created.", new JObject() { [ModelDBEntry.KEY_NAME_MODEL_ID] = ModelID })); } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction); if (bGetClearanceForModelName) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME + ":" + NewModelObject.ModelName, _ErrorMessageAction); } } }
private BWebServiceResponse CreateUser(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { var NewUserParameters = new JObject(); bool bIsInternalCall = BWebUtilities.DoesContextContainHeader(out List <string> ICHVs, out string _, _Context, "internal-call-secret") && BUtility.CheckAndGetFirstStringFromList(ICHVs, out string ICH) && ICH == CommonData.INTERNAL_CALL_PRIVATE_KEY; using (var InputStream = _Context.Request.InputStream) { 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); } foreach (var MustHaveProperty in UserDBEntry.MustHaveProperties) { if (!PropertiesList.Contains(MustHaveProperty)) { return(BWebResponse.BadRequest("Request body must contain all necessary fields.")); } } foreach (var Child in ParsedBody) { if (UserDBEntry.UpdatableProperties.Contains(Child.Key)) { if (!UserDBEntry.UpdatablePropertiesValidityCheck[Child.Key](Child.Value)) { return(BWebResponse.BadRequest("Given field " + Child.Key + " has invalid value.")); } NewUserParameters[Child.Key] = Child.Value; } } } catch (Exception e) { _ErrorMessageAction?.Invoke("User_CreateListUsers->UpdateUserInfo: Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } int ExistenceTrial = 0; string NewUserID = null; while (NewUserID == null && ExistenceTrial < 3) { if (!UserDBEntry.GenerateUserID(out NewUserID, _ErrorMessageAction)) { return(BWebResponse.InternalError("User ID generation has failed.")); } if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), NewUserID, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(NewUserID), UserDBEntry.MustHaveProperties, out JObject ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database existence check operation has failed.")); } if (ExistenceCheck != null) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), NewUserID, _ErrorMessageAction); NewUserID = null; ExistenceTrial++; } else { break; } } if (NewUserID == null) { return(BWebResponse.InternalError("Unique ID generation operation has failed.")); } //For other elements to be created without any elements var NewUserObject = JsonConvert.DeserializeObject <UserDBEntry>(NewUserParameters.ToString()); bool bEmailAtomicnessSet = false, bUsernameAtomicnessSet = false; try { if (NewUserObject.UserEmail != null && NewUserObject.UserEmail.Length > 0) { NewUserObject.UserEmail = NewUserObject.UserEmail.ToLower(); if (!bIsInternalCall && NewUserObject.UserEmail.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("E-mail address cannot end with " + Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)); } if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL + ":" + NewUserObject.UserEmail, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bEmailAtomicnessSet = true; if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(NewUserObject.UserEmail), UniqueUserFieldsDBEntry.Properties, out JObject _ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database operation failed.")); } if (_ExistenceCheck != null) { return(BWebResponse.Conflict("A user with same user e-mail already exists.")); } } if (NewUserObject.UserName != null && NewUserObject.UserName.Length > 0) { if (!bIsInternalCall && NewUserObject.UserName.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("Username cannot end with " + Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)); } if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME + ":" + NewUserObject.UserName, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bUsernameAtomicnessSet = true; if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME, new BPrimitiveType(NewUserObject.UserName), UniqueUserFieldsDBEntry.Properties, out JObject _ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database operation failed.")); } if (_ExistenceCheck != null) { return(BWebResponse.Conflict("A user with same username already exists.")); } } if (!Controller_Rights_Internal.Get().PerformGetRequestToGetGloballySharedModelIds(out List <string> GloballySharedModelIds, _ErrorMessageAction)) { return(BWebResponse.InternalError("Get-globally-shared-models operation failed.")); } NewUserObject.UserSharedModels = GloballySharedModelIds; if (!DatabaseService.UpdateItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(NewUserID), JObject.Parse(JsonConvert.SerializeObject(NewUserObject)), out JObject _, EBReturnItemBehaviour.DoNotReturn, DatabaseService.BuildAttributeNotExistCondition(UserDBEntry.KEY_NAME_USER_ID), _ErrorMessageAction)) { return(BWebResponse.InternalError("Database operation failed.")); } if (!Controller_Rights_Internal.Get().GetUserDefaultRights(out JArray DefaultRights, NewUserID, _ErrorMessageAction)) { Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(NewUserID)); return(BWebResponse.InternalError("Default rights obtaining operation has failed.")); } if (!Controller_Rights_Internal.Get().GrantUserWithRights(true, NewUserID, DefaultRights, _ErrorMessageAction)) { Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(NewUserID)); return(BWebResponse.InternalError("Right granting operation has failed.")); } if (NewUserObject.UserEmail != null && NewUserObject.UserEmail.Length > 0) { Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(NewUserObject.UserEmail), new JObject() { [UserDBEntry.KEY_NAME_USER_ID] = NewUserID }); } if (NewUserObject.UserName != null && NewUserObject.UserName.Length > 0) { Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME, new BPrimitiveType(NewUserObject.UserName), new JObject() { [UserDBEntry.KEY_NAME_USER_ID] = NewUserID }); } Controller_UserActions.Get().BroadcastUserAction(new Action_UserCreated( NewUserID, NewUserObject.UserEmail, NewUserObject.UserName ), _ErrorMessageAction); } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), NewUserID, _ErrorMessageAction); if (bEmailAtomicnessSet) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL + ":" + NewUserObject.UserEmail, _ErrorMessageAction); } if (bUsernameAtomicnessSet) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME + ":" + NewUserObject.UserName, _ErrorMessageAction); } } return(BWebResponse.StatusCreated("User has been created.", new JObject() { [UserDBEntry.KEY_NAME_USER_ID] = NewUserID })); }
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); }
private void Cleanup_AuthMethods(Action <string> _ErrorMessageAction = null) { if (!DatabaseService.ScanTable( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), out List <JObject> AuthEntries, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Table does not exist or ScanTable operation has failed."); return; } if (AuthEntries.Count == 0) { return; } foreach (var Current in AuthEntries) { var Casted = JsonConvert.DeserializeObject <AuthDBEntry>(Current.ToString()); var EntryKey = (string)Current[AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY]; if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction)) { continue; } try { bool bDeleteEntry = false; if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(Casted.UserID), UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { continue; } if (UserObject == null) { //User does not exist bDeleteEntry = true; } else { bool bFound = false; bool bSSOMethod = false; bool bSSORefreshTokenExpired = false; var User = JsonConvert.DeserializeObject <UserDBEntry>(UserObject.ToString()); for (var i = 0; i < User.AuthMethods.Count; i++) { var UserAuthMethod = User.AuthMethods[i]; var UserAuthMethodKey = ""; if (UserAuthMethod.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD) { if (UserAuthMethod.UserEmail == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserEmail.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0) { continue; } UserAuthMethodKey = UserAuthMethod.UserEmail + UserAuthMethod.PasswordMD5; if (UserAuthMethodKey == EntryKey) { bFound = true; //SSO Auth Method Expiry Check if (UserAuthMethod.UserEmail.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { bSSOMethod = true; var QueryParameters = Controller_SSOAccessToken.MakeSSOQueryParameters(UserAuthMethod.PasswordMD5); if (Controller_SSOAccessToken.IsTokenExpiredOrInvalid(out Dictionary <string, BPrimitiveType> _Result, MemoryService, QueryParameters, _ErrorMessageAction) || _Result == null) { bSSORefreshTokenExpired = true; User.AuthMethods.RemoveAt(i); } } break; } } else { if (UserAuthMethod.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD) { if (UserAuthMethod.UserName == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserName.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0) { continue; } UserAuthMethodKey = UserAuthMethod.UserName + UserAuthMethod.PasswordMD5; } else if (UserAuthMethod.Method == AuthMethod.Methods.API_KEY_METHOD) { UserAuthMethodKey = UserAuthMethod.ApiKey; } if (UserAuthMethodKey == EntryKey) { bFound = true; break; } } } if (!bFound) { bDeleteEntry = true; } else if (bSSOMethod && bSSORefreshTokenExpired) { _ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Expired sso auth method has been found. Deleting the entry."); bDeleteEntry = true; DatabaseService.UpdateItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(Casted.UserID), JObject.Parse(JsonConvert.SerializeObject(User)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction); } } if (bDeleteEntry) { DatabaseService.DeleteItem( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, new BPrimitiveType(EntryKey), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction); MemoryService.DeleteKey( CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + EntryKey, _ErrorMessageAction); } } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction); } } }
private BWebServiceResponse DeleteBaseRightForUser(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { var UserKey = new BPrimitiveType(RequestedUserID); if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-user-info operation has failed.")); } if (UserObject == null) { return(BWebResponse.NotFound("User does not exist.")); } if (!UserObject.ContainsKey(UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY)) { return(BWebResponse.NotFound("User does not have any base rights.")); } var BaseAccessScopeAsArray = (JArray)UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY]; var NewBaseAccessScopeAsList = new List <AccessScope>(); //Check existence of access scope var ExistingAccessScopeIndex = -1; int j = 0; foreach (JObject BaseAccessScopeObject in BaseAccessScopeAsArray) { var Scope = JsonConvert.DeserializeObject <AccessScope>(BaseAccessScopeObject.ToString()); if (ExistingAccessScopeIndex == -1 && Scope.WildcardPath == RequestedBaseRightWildcard) { ExistingAccessScopeIndex = j; } else { NewBaseAccessScopeAsList.Add(Scope); } j++; } if (ExistingAccessScopeIndex == -1) { return(BWebResponse.NotFound("User does not have the given base right.")); } BaseAccessScopeAsArray.RemoveAt(ExistingAccessScopeIndex); UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY] = BaseAccessScopeAsArray; Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserObject); MemoryService.SetKeyValue(CommonData.MemoryQueryParameters, new Tuple <string, BPrimitiveType>[] { new Tuple <string, BPrimitiveType>( UserBaseAccessMEntry.M_KEY_NAME_USER_ID + RequestedUserID, new BPrimitiveType(JsonConvert.SerializeObject(new UserBaseAccessMEntry() { BaseAccessScope = NewBaseAccessScopeAsList }))) }, _ErrorMessageAction); return(BWebResponse.StatusOK("Base right has been deleted.")); }
//TODO: If SSO is enabled for user; when it loses access to the tenant, delete all rights but keep the models and user. private BWebServiceResponse DeleteAccessMethodForUser(HttpListenerContext _Context, out bool _bSetClearanceForApiKey, out string _ApiKey, Action <string> _ErrorMessageAction) { _bSetClearanceForApiKey = false; _ApiKey = null; var UserKey = new BPrimitiveType(RequestedUserID); if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-user-info operation has failed.")); } if (UserObject == null) { return(BWebResponse.NotFound("User does not exist.")); } if (!UserObject.ContainsKey(UserDBEntry.AUTH_METHODS_PROPERTY)) { return(BWebResponse.NotFound("User does not have any auth method.")); } bool bFound = false; var AuthMethodsArray = (JArray)UserObject[UserDBEntry.AUTH_METHODS_PROPERTY]; for (var i = (AuthMethodsArray.Count - 1); i >= 0; i--) { var MethodObject = (JObject)AuthMethodsArray[i]; var Method = JsonConvert.DeserializeObject <AuthMethod>(MethodObject.ToString()); string AuthMethodKey = null; switch (Method.Method) { case AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD: { if (!bIsInternalCall && Method.UserEmail.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("This auth method cannot be deleted.")); } AuthMethodKey = Method.UserEmail + Method.PasswordMD5; break; } case AuthMethod.Methods.USER_NAME_PASSWORD_METHOD: { AuthMethodKey = Method.UserName + Method.PasswordMD5; break; } case AuthMethod.Methods.API_KEY_METHOD: { AuthMethodKey = Method.ApiKey; _bSetClearanceForApiKey = true; _ApiKey = Method.ApiKey; if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + Method.ApiKey, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } break; } } if (AuthMethodKey == RequestedAuthMethodKey) { AuthMethodsArray.RemoveAt(i); bFound = true; } } if (!bFound) { return(BWebResponse.NotFound("Auth method does not exist.")); } //Update UserDBEntry Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, UserObject); //Delete AuthDBEntry Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, new BPrimitiveType(RequestedAuthMethodKey)); if (_bSetClearanceForApiKey) { //Delete ApiKey from UniqueUserFields Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY, new BPrimitiveType(_ApiKey)); } //Delete from cache MemoryService.DeleteKey( CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + RequestedAuthMethodKey, _ErrorMessageAction); return(BWebResponse.StatusOK("Access method has been deleted.")); }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { if (_Context.Request.HttpMethod != "POST") { _ErrorMessageAction?.Invoke("StopProcessRequest: POST methods is accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("POST methods is accepted. But received request method: " + _Context.Request.HttpMethod)); } string BucketName = null; string RelativeFilename = null; string ConversionID_FromRelativeUrl_UrlEncoded = null; using (var InputStream = _Context.Request.InputStream) { var NewObjectJson = new JObject(); using (var ResponseReader = new StreamReader(InputStream)) { try { var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd()); if (!ParsedBody.ContainsKey("bucketName") || !ParsedBody.ContainsKey("rawFileRelativeUrl")) { return(BWebResponse.BadRequest("Request body must contain all necessary fields.")); } var BucketNameToken = ParsedBody["bucketName"]; var RawFileRelativeUrlToken = ParsedBody["rawFileRelativeUrl"]; if (BucketNameToken.Type != JTokenType.String || RawFileRelativeUrlToken.Type != JTokenType.String) { return(BWebResponse.BadRequest("Request body contains invalid fields.")); } BucketName = (string)BucketNameToken; ConversionID_FromRelativeUrl_UrlEncoded = WebUtility.UrlEncode((string)RawFileRelativeUrlToken); RelativeFilename = (string)RawFileRelativeUrlToken; } catch (Exception e) { _ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } //Temporarily, TODO: Change this when the implementation is in place. if (!DatabaseService.DeleteItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction)) { if (!DatabaseService.GetItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded), FileConversionDBEntry.Properties, out JObject _ReturnObject, _ErrorMessageAction) || _ReturnObject != null) { return(BWebResponse.InternalError("Database error.")); } } if (!BatchProcessingCreationService.Instance.StopBatchProcess(BucketName, RelativeFilename, _ErrorMessageAction)) { return(BWebResponse.InternalError("Failed to stop pod or connect to kubernetess")); } return(BWebResponse.StatusAccepted("Request has been accepted; process is now being stopped.")); }
private BWebServiceResponse UpdateUserInfo(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { var UpdateFieldsUserEntry = new JObject(); var UpdateFieldsAuthEntry = new JObject(); string NewEmailChange = null; string NewUserNameChange = null; using (var InputStream = _Context.Request.InputStream) { using (var ResponseReader = new StreamReader(InputStream)) { try { var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd()); foreach (var Child in ParsedBody) { if (UserDBEntry.UpdatableProperties.Contains(Child.Key)) { if (!UserDBEntry.UpdatablePropertiesValidityCheck[Child.Key](Child.Value)) { return(BWebResponse.BadRequest("Given field " + Child.Key + " has invalid value.")); } UpdateFieldsUserEntry[Child.Key] = Child.Value; } if (AuthDBEntry.UpdatableProperties.Contains(Child.Key)) { UpdateFieldsAuthEntry[Child.Key] = Child.Value; } if (Child.Key == UserDBEntry.USER_EMAIL_PROPERTY) { NewEmailChange = ((string)Child.Value).ToLower(); if (NewEmailChange.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("Email address cannot end with " + Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)); } } else if (Child.Key == UserDBEntry.USER_NAME_PROPERTY) { NewUserNameChange = (string)Child.Value; if (NewUserNameChange.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("Username cannot end with " + Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)); } } } } catch (Exception e) { _ErrorMessageAction?.Invoke("User_GetUpdateDeleteUser->UpdateUserInfo: Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } if (UpdateFieldsUserEntry.Count == 0) { return(BWebResponse.BadRequest("Request does not contain any matching field with the expected structure.")); } bool bNewEmailAtomicnessSet = false, bNewUsernameAtomicnessSet = false; try { if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(RequestedUserID), UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-user-info operation has failed.")); } if (UserObject == null) { return(BWebResponse.NotFound("User does not exist.")); } var bEmailExistInUserObject = UserObject.ContainsKey(UserDBEntry.USER_EMAIL_PROPERTY); var bUsernameExistInUserObject = UserObject.ContainsKey(UserDBEntry.USER_NAME_PROPERTY); if (NewEmailChange != null && bEmailExistInUserObject && (string)UserObject[UserDBEntry.USER_EMAIL_PROPERTY] == NewEmailChange) { NewEmailChange = null; UpdateFieldsUserEntry.Remove(UserDBEntry.USER_EMAIL_PROPERTY); UpdateFieldsAuthEntry.Remove(AuthDBEntry.USER_EMAIL_PROPERTY); } else if (NewEmailChange != null) { if (bEmailExistInUserObject && ((string)UserObject[UserDBEntry.USER_EMAIL_PROPERTY]).EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("E-mail address cannot be changed for this account type.")); } if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL + ":" + NewEmailChange, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bNewEmailAtomicnessSet = true; if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(NewEmailChange), UniqueUserFieldsDBEntry.Properties, out JObject ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-uniqueness-info operation has failed.")); } if (ExistenceCheck != null) { return(BWebResponse.Conflict("A user with same user e-mail already exists.")); } } if (NewUserNameChange != null && UserObject.ContainsKey(UserDBEntry.USER_NAME_PROPERTY) && (string)UserObject[UserDBEntry.USER_NAME_PROPERTY] == NewUserNameChange) { NewUserNameChange = null; UpdateFieldsUserEntry.Remove(UserDBEntry.USER_NAME_PROPERTY); UpdateFieldsAuthEntry.Remove(AuthDBEntry.USER_NAME_PROPERTY); } else if (NewUserNameChange != null) { if (bUsernameExistInUserObject && ((string)UserObject[UserDBEntry.USER_NAME_PROPERTY]).EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { return(BWebResponse.BadRequest("Username cannot be changed for this account type.")); } if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME + ":" + NewUserNameChange, _ErrorMessageAction)) { return(BWebResponse.InternalError("Atomic operation control has failed.")); } bNewUsernameAtomicnessSet = true; if (!DatabaseService.GetItem( UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME, new BPrimitiveType(NewUserNameChange), UniqueUserFieldsDBEntry.Properties, out JObject ExistenceCheck, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database fetch-uniqueness-info operation has failed.")); } if (ExistenceCheck != null) { return(BWebResponse.Conflict("A user with same username already exists.")); } } return(UpdateUserInfo_Internal( _Context, NewEmailChange, NewUserNameChange, UserObject, UpdateFieldsUserEntry, UpdateFieldsAuthEntry, _ErrorMessageAction)); } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction); if (bNewEmailAtomicnessSet) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL + ":" + NewEmailChange, _ErrorMessageAction); } if (bNewUsernameAtomicnessSet) { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME + ":" + NewUserNameChange, _ErrorMessageAction); } } }
private bool TestAddToList(int _TestStepNo) { PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Log-> Testing AddElementsToArrayItem-1..."); bool bLocalFailure = !SelectedDBService.AddElementsToArrayItem( TableName, Key, new BPrimitiveType("test_1"), "test_list", new BPrimitiveType[] { new BPrimitiveType("test_value_1"), new BPrimitiveType("test_value_2"), new BPrimitiveType("test_value_3"), new BPrimitiveType("test_value_4") }, out JObject ReturnValue, EBReturnItemBehaviour.ReturnAllOld, null, (string Message) => { Console.WriteLine("Step " + _TestStepNo + "->" + "TestAddToList->Error-> " + Message); bLocalFailure = true; }); if (bLocalFailure) { PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Error-> AddElementsToArrayItem-1 failed."); return(false); } PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Log-> AddElementsToArrayItem-1 succeed. Returned: " + ReturnValue?.ToString()); PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Log-> Testing AddElementsToArrayItem-2. Expecting failure..."); bLocalFailure = !SelectedDBService.AddElementsToArrayItem( TableName, Key, new BPrimitiveType("test_1"), "test_list", new BPrimitiveType[] { new BPrimitiveType("test_value_2"), new BPrimitiveType("test_value_5") }, out ReturnValue, EBReturnItemBehaviour.ReturnAllOld, SelectedDBService.BuildArrayElementNotExistCondition(new BPrimitiveType("test_value_1")), (string Message) => { Console.WriteLine("Step " + _TestStepNo + "->" + "TestAddToList->Error-> " + Message); bLocalFailure = true; }); if (!bLocalFailure) { PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Error-> AddElementsToArrayItem-2 did not fail."); return(false); } PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Log-> AddElementsToArrayItem-2 successfully failed. Returned: " + ReturnValue?.ToString()); bLocalFailure = !SelectedDBService.GetItem( TableName, Key, new BPrimitiveType("test_1"), new string[] { "test_list" }, out ReturnValue, (string Message) => { Console.WriteLine("Step " + _TestStepNo + "->" + "TestAddToList->Error-> " + Message); bLocalFailure = true; }); if (bLocalFailure) { PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Error-> GetItem-1 has failed."); return(false); } PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestAddToList->Log-> GetItem-1 successfully completed. Returned: " + ReturnValue?.ToString()); return(true); }
private void Cleanup_UniqueFileFields(Action <string> _ErrorMessageAction) { if (!DatabaseService.ScanTable( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), out List <JObject> UniqueFieldsEntries, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("Cleanup_UniqueFileFields: Table does not exist or ScanTable operation has failed."); return; } if (UniqueFieldsEntries.Count == 0) { return; } foreach (var Current in UniqueFieldsEntries) { if (!Current.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID)) { continue; } if (!Current.ContainsKey(UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME)) { continue; } var ModelUniqueName = (string)Current[UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME]; var ModelID = (string)Current[ModelDBEntry.KEY_NAME_MODEL_ID]; var Casted = JsonConvert.DeserializeObject <UniqueFileFieldsDBEntry>(Current.ToString()); try { if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction)) { continue; } bool bDeleteEntry = false; if (!DatabaseService.GetItem( ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelDBEntry.KEY_NAME_MODEL_ID, new BPrimitiveType(ModelID), ModelDBEntry.Properties, out JObject ModelObject, _ErrorMessageAction)) { continue; } if (ModelObject == null) { //Model does not exist bDeleteEntry = true; } else { var Model = JsonConvert.DeserializeObject <ModelDBEntry>(ModelObject.ToString()); bDeleteEntry = ModelUniqueName != Model.ModelName; } if (bDeleteEntry) { DatabaseService.DeleteItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(ModelUniqueName), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction); } } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction); } } }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { if (_Context.Request.HttpMethod != "POST") { _ErrorMessageAction?.Invoke("StartProcessRequest: POST methods is accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("POST methods is accepted. But received request method: " + _Context.Request.HttpMethod)); } var NewDBEntry = new FileConversionDBEntry() { ConversionStatus = (int)EInternalProcessStage.Queued }; string NewConversionID_FromRelativeUrl_UrlEncoded = null; string BucketName = null; string RelativeFileName = null; string ZipMainAssembly = ""; using (var InputStream = _Context.Request.InputStream) { var NewObjectJson = new JObject(); using (var ResponseReader = new StreamReader(InputStream)) { try { var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd()); if (!ParsedBody.ContainsKey("bucketName") || !ParsedBody.ContainsKey("rawFileRelativeUrl")) { return(BWebResponse.BadRequest("Request body must contain all necessary fields.")); } var BucketNameToken = ParsedBody["bucketName"]; var RawFileRelativeUrlToken = ParsedBody["rawFileRelativeUrl"]; if (BucketNameToken.Type != JTokenType.String || RawFileRelativeUrlToken.Type != JTokenType.String) { return(BWebResponse.BadRequest("Request body contains invalid fields.")); } if (ParsedBody.ContainsKey("zipTypeMainAssemblyFileNameIfAny")) { var ZipMainAssemblyToken = ParsedBody["zipTypeMainAssemblyFileNameIfAny"]; if (ZipMainAssemblyToken.Type != JTokenType.String) { return(BWebResponse.BadRequest("Request body contains invalid fields.")); } ZipMainAssembly = (string)ZipMainAssemblyToken; } NewDBEntry.BucketName = (string)BucketNameToken; NewConversionID_FromRelativeUrl_UrlEncoded = WebUtility.UrlEncode((string)RawFileRelativeUrlToken); BucketName = (string)BucketNameToken; RelativeFileName = (string)RawFileRelativeUrlToken; } catch (Exception e) { _ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } if (BucketName == null || RelativeFileName == null) { return(BWebResponse.InternalError("No BucketName or FileName")); } BDatabaseAttributeCondition UpdateCondition = DatabaseService.BuildAttributeNotExistCondition(FileConversionDBEntry.KEY_NAME_CONVERSION_ID); //If a process was completed (success or failure) then allow reprocessing //Only stop if a process is currently busy processing or already queued if (DatabaseService.GetItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(NewConversionID_FromRelativeUrl_UrlEncoded), FileConversionDBEntry.Properties, out JObject ConversionObject )) { if (ConversionObject != null && ConversionObject.ContainsKey("conversionStatus")) { EInternalProcessStage ExistingStatus = (EInternalProcessStage)(int)ConversionObject["conversionStatus"]; if (ExistingStatus == EInternalProcessStage.ProcessFailed || ExistingStatus == EInternalProcessStage.ProcessComplete) { UpdateCondition = null; } } } if (!DatabaseService.UpdateItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(NewConversionID_FromRelativeUrl_UrlEncoded), JObject.Parse(JsonConvert.SerializeObject(NewDBEntry)), out JObject _ExistingObject, EBReturnItemBehaviour.DoNotReturn, UpdateCondition, _ErrorMessageAction)) { return(BWebResponse.Conflict("File is already being processed/queued.")); } try { if (BatchProcessingCreationService.Instance.StartBatchProcess(BucketName, RelativeFileName, ZipMainAssembly, out string _PodName, _ErrorMessageAction)) { //Code for initial method of starting optimizer after pixyz completes //return BWebResponse.StatusAccepted("Request has been accepted; process is now being started."); if (BatchProcessingCreationService.Instance.StartFileOptimizer(BucketName, RelativeFileName, _ErrorMessageAction)) { return(BWebResponse.StatusAccepted("Request has been accepted; process is now being started.")); } else { NewDBEntry.ConversionStatus = (int)EInternalProcessStage.ProcessFailed; if (!DatabaseService.UpdateItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(NewConversionID_FromRelativeUrl_UrlEncoded), JObject.Parse(JsonConvert.SerializeObject(NewDBEntry)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction)) { return(BWebResponse.InternalError("Failed to start the batch process and experienced a Database error")); } //Try kill pixyz pod that we have succeeded in creating if (!BatchProcessingCreationService.Instance.TryKillPod(_PodName, "cip-batch")) { return(BWebResponse.InternalError("Failed to start the unreal optimizer and failed to kill pixyz pod")); } return(BWebResponse.InternalError("Failed to start the batch process and experienced a Database error")); } } else { NewDBEntry.ConversionStatus = (int)EInternalProcessStage.ProcessFailed; if (!DatabaseService.UpdateItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(NewConversionID_FromRelativeUrl_UrlEncoded), JObject.Parse(JsonConvert.SerializeObject(NewDBEntry)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction)) { return(BWebResponse.InternalError("Failed to start the batch process and experienced a Database error")); } return(BWebResponse.InternalError("Failed to start the batch process")); } }