private bool TestScanTable(int _TestStepNo)
{
//Test scan items
PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestScanTable->Log-> Testing ScanTable...");
bool bLocalFailure = !SelectedDBService.ScanTable(
TableName,
out List <JObject> Result_4,
(string Message) =>
{
Console.WriteLine("Step " + _TestStepNo + "->" + "TestScanTable->Error-> " + Message);
bLocalFailure = true;
});
if (bLocalFailure)
{
PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestScanTable->Error-> ScanTable failed.");
return(false);
}
string Readable = "";
if (Result_4 != null)
{
foreach (var Cur in Result_4)
{
Readable += Cur.ToString() + "\n";
}
}
PrintAction?.Invoke("Step " + _TestStepNo + "->" + "TestScanTable->Log-> ScanTable succeed. Returned: " + Readable);
return(true);
}
public static BWebServiceResponse ProcessCommon(HttpListenerContext _Context, IBDatabaseServiceInterface _DatabaseService, Action <string> _ErrorMessageAction = null)
{
if (_Context.Request.HttpMethod != "GET")
{
_ErrorMessageAction?.Invoke("ListGloballySharedModelIds: 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));
}
if (!_DatabaseService.ScanTable(GloballySharedModelIDsDBEntry.DBSERVICE_GLOBALLY_SHARED_MODEL_IDS_TABLE(), out List <JObject> GloballySharedModelIDObjects, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Scanning table for listing items has failed."));
}
var SharedModelIds = new JArray();
foreach (var Current in GloballySharedModelIDObjects)
{
if (Current != null && Current.ContainsKey(GloballySharedModelIDsDBEntry.KEY_NAME_MODEL_ID))
{
SharedModelIds.Add((string)Current[GloballySharedModelIDsDBEntry.KEY_NAME_MODEL_ID]);
}
}
return(BWebResponse.StatusOK("Globally shared models have successfully been retrieved.", new JObject()
{
["sharedModelIds"] = SharedModelIds
}));
}
private bool FindMissingUsersInDatabase(out List <UserPrincipal> _UsersToBePut, List <UserPrincipal> _Users, Action <string> _ErrorMessageAction)
{
_UsersToBePut = null;
var TmpDictionary = new Dictionary <string, UserPrincipal>();
foreach (var AzureUser in _Users)
{
TmpDictionary.Add(AzureUser.Email + Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX, AzureUser);
}
if (!DatabaseService.ScanTable(
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
out List <JObject> Result,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("Scan unique-users-fields operation has failed.");
return(false);
}
foreach (var Existing in Result)
{
if (Existing.TryGetValue(UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, out JToken ExistingEmailToken) &&
ExistingEmailToken.Type == JTokenType.String)
{
TmpDictionary.Remove((string)ExistingEmailToken); //TryRemove
}
}
_UsersToBePut = TmpDictionary.Values.ToList();
return(true);
}
private BWebServiceResponse ListUsers(Action <string> _ErrorMessageAction)
{
if (!DatabaseService.ScanTable(UserDBEntry.DBSERVICE_USERS_TABLE(), out List <JObject> UsersJson, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Scan-table operation has failed."));
}
var Result = new JObject();
var UsersArray = new JArray();
Result["users"] = UsersArray;
foreach (var UserJson in UsersJson)
{
var DecimatedUserJson = new JObject();
foreach (var GetKey in UserDBEntry.GetableProperties)
{
DecimatedUserJson[GetKey] = UserJson[GetKey];
}
DecimatedUserJson[UserDBEntry.KEY_NAME_USER_ID] = UserJson[UserDBEntry.KEY_NAME_USER_ID];
UsersArray.Add(DecimatedUserJson);
}
return(BWebResponse.StatusOK("List users operation has succeeded.", Result));
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
//Any verb is accepted.
var StartTimestamp = MSSinceEpoch();
if (!DatabaseService.ScanTable(
ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(),
out List <JObject> URLTasks_UrlEncoded,
_ErrorMessageAction))
{
return(BWebResponse.StatusOK("Table does not exist or ScanTable operation has failed.")); //Still ok.
}
if (URLTasks_UrlEncoded.Count == 0)
{
return(BWebResponse.StatusOK("There is no task in the database."));
}
var URLTasks = new List <ScheduledUrlTaskDBEntry>();
foreach (var Current in URLTasks_UrlEncoded)
{
URLTasks.Add(JsonConvert.DeserializeObject <ScheduledUrlTaskDBEntry>(Current.ToString()));
}
long RemainedMS = 50000 - (MSSinceEpoch() - StartTimestamp); //60-50=10 seconds is for possible delays.
while (RemainedMS > 0)
{
var BeforeTS = MSSinceEpoch();
SecondCheck(_Context, URLTasks, _ErrorMessageAction);
var Diff = MSSinceEpoch() - BeforeTS;
if (Diff < 10000)
{
Thread.Sleep(10000 - (int)Diff);
}
RemainedMS -= (MSSinceEpoch() - BeforeTS);
}
return(BWebResponse.StatusAccepted("Request has been accepted."));
}
protected override BWebServiceResponse OnRequestPP(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (_Context.Request.HttpMethod != "GET")
{
_ErrorMessageAction?.Invoke("ListRegisteredUserEmails: 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));
}
if (!DatabaseService.ScanTable(UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), out List <JObject> Result, _ErrorMessageAction))
{
return(BWebResponse.InternalError("ScanTable has failed."));
}
if (Result == null)
{
return(BWebResponse.StatusOK("Ok.", new JObject()
{
["emailAddresses"] = new JArray()
}));
}
var FinalResultArray = new JArray();
foreach (var Current in Result)
{
if (Current != null &&
Current.ContainsKey(UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL) &&
Current.ContainsKey(UserDBEntry.KEY_NAME_USER_ID))
{
FinalResultArray.Add(
new JObject()
{
[UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL] = (string)Current[UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL],
[UserDBEntry.KEY_NAME_USER_ID] = (string)Current[UserDBEntry.KEY_NAME_USER_ID]
});
}
}
return(BWebResponse.StatusOK("Ok.", new JObject()
{
["emailAddresses"] = FinalResultArray
}));
}
private BWebServiceResponse ListModels(Action <string> _ErrorMessageAction)
{
if (!DatabaseService.ScanTable(ModelDBEntry.DBSERVICE_MODELS_TABLE(), out List <JObject> ModelsJson, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Scan-table operation has failed."));
}
var Result = new JObject();
var ModelsArray = new JArray();
Result["models"] = ModelsArray;
foreach (var ModelJson in ModelsJson)
{
var AsModel = JsonConvert.DeserializeObject <ModelDBEntry>(ModelJson.ToString());
AsModel.Prune_NonGettableProperties();
ModelsArray.Add(JObject.Parse(ModelJson.ToString()));
}
return(BWebResponse.StatusOK("List models operation has succeeded.", Result));
}
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 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 void Cleanup_UserModels(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (!DatabaseService.ScanTable(
UserDBEntry.DBSERVICE_USERS_TABLE(),
out List <JObject> UserEntries,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("Cleanup_UserModels: Table does not exist or ScanTable operation has failed.");
return;
}
if (UserEntries.Count == 0)
{
return;
}
//Get cad file service endpoint from internal set state
if (!InternalSetState.GetValueFromMemoryService(
out string CADFileServiceEndpoint,
InternalSetState.CAD_FILE_SERVICE_ENDPOINT_PROPERTY,
MemoryService,
(string _Message) =>
{
_ErrorMessageAction?.Invoke("Cleanup_UserModels: Unable to get CadFileServiceEndpoint: " + _Message);
}))
{
return;
}
foreach (var UserJObject in UserEntries)
{
var UserID = (string)UserJObject[UserDBEntry.KEY_NAME_USER_ID];
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), UserID, _ErrorMessageAction))
{
continue;
}
try
{
var UserID_Primitive = new BPrimitiveType(UserID);
var UserDeserialized = JsonConvert.DeserializeObject <UserDBEntry>(UserJObject.ToString());
var UserModelIDsJArray = new JArray();
var UserSharedModelIDsJArray = new JArray();
foreach (var CurrentModel in UserDeserialized.UserModels)
{
UserModelIDsJArray.Add(CurrentModel);
}
foreach (var CurrentSharedModel in UserDeserialized.UserSharedModels)
{
UserSharedModelIDsJArray.Add(CurrentSharedModel);
}
var RequestObject = new JObject()
{
["userModelIds"] = UserModelIDsJArray,
["userSharedModelIds"] = UserSharedModelIDsJArray
};
// 3d/models/internal/check_models_exist will return CheckedUserModelIDs and CheckedUserSharedModelIDs list
List <string> CheckedUserModelIDs = new List <string>();
List <string> CheckedUserSharedModelIDs = new List <string>();
GetTracingService()?.On_FromServiceToService_Sent(_Context, _ErrorMessageAction);
var Result = BWebServiceExtraUtilities.InterServicesRequest(new BWebServiceExtraUtilities.InterServicesRequestRequest()
{
DestinationServiceUrl = CADFileServiceEndpoint + "/3d/models/internal/check_models_exist?secret=" + InternalCallPrivateKey,
RequestMethod = "POST",
bWithAuthToken = true,
UseContextHeaders = _Context,
ContentType = "application/json",
Content = new BStringOrStream(RequestObject.ToString()),
ExcludeHeaderKeysForRequest = null
},
false,
_ErrorMessageAction);
GetTracingService()?.On_FromServiceToService_Received(_Context, _ErrorMessageAction);
string ResponseContentAsString = "";
JObject ResponseContentAsJson = null;
try
{
ResponseContentAsString = Result.Content.String;
ResponseContentAsJson = JObject.Parse(ResponseContentAsString);
var ArrayUserModelsTmp = (JArray)ResponseContentAsJson["checkedUserModelIds"];
if (ArrayUserModelsTmp != null)
{
foreach (var Tmp in ArrayUserModelsTmp)
{
CheckedUserModelIDs.Add((string)Tmp);
}
}
var ArraySharedUserModelsTmp = (JArray)ResponseContentAsJson["checkedUserSharedModelIds"];
if (ArraySharedUserModelsTmp != null)
{
foreach (var Tmp in ArraySharedUserModelsTmp)
{
CheckedUserSharedModelIDs.Add((string)Tmp);
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Cleanup_UserModels: Error occurred during reading response/parsing json: " + e.Message + ", trace: " + e.StackTrace + ", response content: " + ResponseContentAsString + ", response code: " + Result.ResponseCode);
continue;
}
if (!Result.bSuccess || Result.ResponseCode >= 400)
{
_ErrorMessageAction?.Invoke("Cleanup_UserModels: Request did not end up with success. Response content: " + ResponseContentAsString + ", response code: " + Result.ResponseCode);
continue;
}
UserDeserialized.UserModels = new List <string>(CheckedUserModelIDs);
UserDeserialized.UserSharedModels = new List <string>(CheckedUserSharedModelIDs);
if (!DatabaseService.UpdateItem(//Fire and forget is not suitable here since there are following calls after DB update which will change the DB structure
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
UserID_Primitive,
JObject.Parse(JsonConvert.SerializeObject(UserDeserialized)),
out JObject _, EBReturnItemBehaviour.DoNotReturn, null,
_ErrorMessageAction))
{
continue;
}
}
finally
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), UserID, _ErrorMessageAction);
}
}
}
