private void DB_UpdateOrPutItem_FireAndForget(
HttpListenerContext _Context,
string _QueryType,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
JObject _UpdateItem,
int _Current_Retry_Count)
{
var RelevantQueue = new ConcurrentQueue <Action_DeliveryEnsurer>();
if (!ActionsDictionary.TryAdd(_Context, RelevantQueue))
{
RelevantQueue = ActionsDictionary[_Context];
}
RelevantQueue.Enqueue(new Action_DeliveryEnsurer_DB_UpdateOrPutItem()
{
QueryType = _QueryType,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
UpdateItemStringified = _UpdateItem.ToString(),
RetryCount = _Current_Retry_Count
});
}
/// <summary>
///
/// <para>GetItem</para>
///
/// <para>Gets an item from a table, if _ValuesToGet is null; will retrieve all.</para>
///
/// <para>Check <seealso cref="IBDatabaseServiceInterface.GetItem"/> for detailed documentation</para>
///
/// </summary>
public bool GetItem(string _Table, string _KeyName, BPrimitiveType _KeyValue, string[] _ValuesToGet, out JObject _Result, Action <string> _ErrorMessageAction = null)
{
_Result = null;
var Table = GetTable(_Table);
if (Table == null)
{
return(false);
}
try
{
var Filter = Builders <BsonDocument> .Filter.Eq(_KeyName, _KeyValue.ToString());
BsonDocument Document = Table.Find(Filter).FirstOrDefault();
if (Document != null)
{
_Result = BsonToJObject(Document);
}
return(true);
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"BDatabaseServiceMongoDB->GetItem: {ex.Message} \n {ex.StackTrace}");
}
return(false);
}
public BAttributeLessOrEqualMongoDb(string Attribute, BPrimitiveType Value) : base(EBDatabaseAttributeConditionType.AttributeNotExist)
{
switch (Value.Type)
{
case EBPrimitiveTypeEnum.Double:
Filter = Builders <BsonDocument> .Filter.Lte(Attribute, Value.AsDouble);
break;
case EBPrimitiveTypeEnum.Integer:
Filter = Builders <BsonDocument> .Filter.Lte(Attribute, Value.AsInteger);
break;
case EBPrimitiveTypeEnum.ByteArray:
Filter = Builders <BsonDocument> .Filter.Lte(Attribute, Value.AsByteArray);
break;
case EBPrimitiveTypeEnum.String:
Filter = Builders <BsonDocument> .Filter.Lte(Attribute, Value.AsString);
break;
}
BuiltCondition = new Tuple <string, Tuple <string, BPrimitiveType> >(Attribute, null);
}
private BWebServiceResponse ListBaseRightsForUser(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."));
}
JArray BaseScopeArray;
if (UserObject.ContainsKey(UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY))
{
BaseScopeArray = (JArray)UserObject[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY];
}
else
{
BaseScopeArray = new JArray();
}
return(BWebResponse.StatusOK("List base rights operation has succeeded.", new JObject()
{
[UserDBEntry.BASE_ACCESS_SCOPE_PROPERTY] = BaseScopeArray
}));
}
private void DB_AddOrRemoveElementsFromArrayItem_FireAndForget(
HttpListenerContext _Context,
string _QueryType,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
string _ElementName,
BPrimitiveType[] _ElementValueEntries,
int _Current_RetryCount = 0)
{
var RelevantQueue = new ConcurrentQueue <Action_DeliveryEnsurer>();
if (!ActionsDictionary.TryAdd(_Context, RelevantQueue))
{
RelevantQueue = ActionsDictionary[_Context];
}
RelevantQueue.Enqueue(new Action_DeliveryEnsurer_DB_Add_Remove_ElementsToArrayItem()
{
QueryType = _QueryType,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
ElementName = _ElementName,
ElementValueEntries = BPrimitiveType_JStringified.ConvertPrimitivesToPrimitiveTypeStructs(_ElementValueEntries).ToList(),
RetryCount = _Current_RetryCount
});
}
public void DB_PutItem_FireAndForget(
HttpListenerContext _Context,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
JObject _NewItem)
{
DB_UpdateOrPutItem_FireAndForget(_Context, Action_DeliveryEnsurer.QUERY_TYPE_DB_PUT_ITEM, _Table, _KeyName, _KeyValue, _NewItem, 0);
}
/// <summary>
///
/// <para>UpdateItem</para>
///
/// <para>Updates an item in a table</para>
///
/// <para>Check <seealso cref="IBDatabaseServiceInterface.UpdateItem"/> for detailed documentation</para>
///
/// </summary>
public bool UpdateItem(string _Table, string _KeyName, BPrimitiveType _KeyValue, JObject _UpdateItem, out JObject _ReturnItem, EBReturnItemBehaviour _ReturnItemBehaviour = EBReturnItemBehaviour.DoNotReturn, BDatabaseAttributeCondition _ConditionExpression = null, Action <string> _ErrorMessageAction = null)
{
_ReturnItem = null;
var Table = GetTable(_Table);
if (Table == null)
{
return(false);
}
try
{
var Filter = Builders <BsonDocument> .Filter.Eq(_KeyName, _KeyValue.ToString());
if (_ConditionExpression != null)
{
Filter = Builders <BsonDocument> .Filter.And(Filter, (_ConditionExpression as BDatabaseAttributeConditionMongo).Filter);
}
JObject NewObject = (JObject)_UpdateItem.DeepClone();
AddKeyToJson(NewObject, _KeyName, _KeyValue);
BsonDocument Document = new BsonDocument {
{ "$set", JObjectToBson(NewObject) }
}; //use $set for preventing to get element name is not valid exception. more info https://stackoverflow.com/a/35441075
if (_ReturnItemBehaviour == EBReturnItemBehaviour.DoNotReturn)
{
Table.UpdateOne(Filter, Document, new UpdateOptions()
{
IsUpsert = true
});
return(true);
}
else
{
BsonDocument OldDocument = Table.FindOneAndUpdate(Filter, Document);
if (Document != null)
{
_ReturnItem = JObject.Parse(Document.ToJson());
return(true);
}
}
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"BDatabaseServiceMongoDB->UpdateItem: {ex.Message} : \n {ex.StackTrace}");
}
return(false);
}
protected Newtonsoft.Json.Linq.JToken FromBPrimitiveTypeToJToken(BPrimitiveType _Primitive)
{
switch (_Primitive.Type)
{
case EBPrimitiveTypeEnum.Double:
return(_Primitive.AsDouble);
case EBPrimitiveTypeEnum.Integer:
return(_Primitive.AsInteger);
case EBPrimitiveTypeEnum.ByteArray:
return(Convert.ToBase64String(_Primitive.AsByteArray));
default:
return(_Primitive.AsString);
}
}
private bool CompareJTokenWithBPrimitive(JToken _Token, BPrimitiveType _Primitive)
{
switch (_Primitive.Type)
{
case EBPrimitiveTypeEnum.Double:
return(_Primitive.AsDouble == (double)_Token);
case EBPrimitiveTypeEnum.Integer:
return(_Primitive.AsInteger == (long)_Token);
case EBPrimitiveTypeEnum.ByteArray:
return(Convert.ToBase64String(_Primitive.AsByteArray) == (string)_Token);
default:
return(_Primitive.AsString == (string)_Token);
}
}
public void DB_RemoveElementsFromArrayItem_FireAndForget(
HttpListenerContext _Context,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
string _ElementName,
BPrimitiveType[] _ElementValueEntries)
{
DB_AddOrRemoveElementsFromArrayItem_FireAndForget(
_Context,
Action_DeliveryEnsurer.QUERY_TYPE_DB_REMOVE_ELEMENTS_FROM_ARRAY_ITEM,
_Table,
_KeyName,
_KeyValue,
_ElementName,
_ElementValueEntries,
0);
}
/// <summary>
///
/// <para>IncrementOrDecrementItemValue</para>
///
/// <para>Updates an item in a table, if item does not exist, creates a new one with only increment/decrement value</para>
///
/// <para>Check <seealso cref="IBDatabaseServiceInterface.IncrementOrDecrementItemValue"/> for detailed documentation</para>
///
/// </summary>
public bool IncrementOrDecrementItemValue(string _Table, string _KeyName, BPrimitiveType _KeyValue, out double _NewValue, string _ValueAttribute, double _IncrementOrDecrementBy, bool _bDecrement = false, Action <string> _ErrorMessageAction = null)
{
_NewValue = 0.0f;
var Table = GetTable(_Table);
if (Table == null)
{
return(false);
}
var Filter = Builders <BsonDocument>
.Filter.Eq(_KeyName, _KeyValue.ToString());
UpdateDefinition <BsonDocument> Update = null;
if (_bDecrement)
{
Update = Builders <BsonDocument> .Update.Inc(_ValueAttribute, -_IncrementOrDecrementBy);
}
else
{
Update = Builders <BsonDocument> .Update.Inc(_ValueAttribute, _IncrementOrDecrementBy);
}
try
{
BsonDocument Document = Table.FindOneAndUpdate(Filter, Update, new FindOneAndUpdateOptions <BsonDocument, BsonDocument>()
{
ReturnDocument = ReturnDocument.After
});
_NewValue = Document.GetValue(_ValueAttribute).AsDouble;
return(true);
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"{ex.Message} : \n {ex.StackTrace}");
}
return(false);
}
public void DB_DeleteItem_FireAndForget(
HttpListenerContext _Context,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue)
{
var RelevantQueue = new ConcurrentQueue <Action_DeliveryEnsurer>();
if (!ActionsDictionary.TryAdd(_Context, RelevantQueue))
{
RelevantQueue = ActionsDictionary[_Context];
}
RelevantQueue.Enqueue(new Action_DeliveryEnsurer_DB_DeleteItem()
{
QueryType = Action_DeliveryEnsurer.QUERY_TYPE_DB_DELETE_ITEM,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
RetryCount = 0
});
}
private void DB_AddOrRemoveElementsFromArrayItem_FireAndForget_Internal(
string _QueryType,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
string _ElementName,
BPrimitiveType[] _ElementValueEntries,
int _Current_RetryCount = 0,
Action <string> _ErrorMessageAction = null)
{
if (DatabaseService == null)
{
return;
}
bool bResult;
if (_QueryType == Action_DeliveryEnsurer.QUERY_TYPE_DB_ADD_ELEMENTS_TO_ARRAY_ITEM)
{
bResult = DatabaseService.AddElementsToArrayItem(_Table, _KeyName, _KeyValue, _ElementName, _ElementValueEntries, out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction);
}
else
{
bResult = DatabaseService.RemoveElementsFromArrayItem(_Table, _KeyName, _KeyValue, _ElementName, _ElementValueEntries, out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction);
}
if (!bResult)
{
BroadcastFailed_FireAndForget_Operation(new Action_DeliveryEnsurer_DB_Add_Remove_ElementsToArrayItem()
{
QueryType = _QueryType,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
ElementName = _ElementName,
ElementValueEntries = BPrimitiveType_JStringified.ConvertPrimitivesToPrimitiveTypeStructs(_ElementValueEntries).ToList(),
RetryCount = _Current_RetryCount
}, _ErrorMessageAction);
}
}
/// <summary>
///
/// <para>DeleteItem</para>
///
/// <para>Deletes an item from a table</para>
/// <para>Note: Whether _ReturnItemBehaviour set to All or Updated, returns All</para>
///
/// <para>Check <seealso cref="IBDatabaseServiceInterface.DeleteItem"/> for detailed documentation</para>
///
/// </summary>
public bool DeleteItem(string _Table, string _KeyName, BPrimitiveType _KeyValue, out JObject _ReturnItem, EBReturnItemBehaviour _ReturnItemBehaviour = EBReturnItemBehaviour.DoNotReturn, Action <string> _ErrorMessageAction = null)
{
_ReturnItem = null;
var Table = GetTable(_Table);
if (Table == null)
{
return(false);
}
var Filter = Builders <BsonDocument> .Filter.Eq(_KeyName, _KeyValue.ToString());
try
{
if (_ReturnItemBehaviour == EBReturnItemBehaviour.DoNotReturn)
{
Table.DeleteOne(Filter);
_ReturnItem = null;
return(true);
}
else
{
BsonDocument Document = Table.FindOneAndDelete(Filter);
if (Document != null)
{
_ReturnItem = BsonToJObject(Document);
}
return(true);
}
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"BDatabaseServiceMongoDB->DeleteItem: {ex.Message} : \n {ex.StackTrace}");
}
return(false);
}
private void DB_UpdateOrPutItem_FireAndForget_Internal(
string _QueryType,
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
JObject _UpdateItem,
int _Current_Retry_Count,
Action <string> _ErrorMessageAction = null)
{
if (DatabaseService == null)
{
return;
}
bool bResult = false;
if (_QueryType == Action_DeliveryEnsurer.QUERY_TYPE_DB_UPDATE_ITEM)
{
bResult = DatabaseService.UpdateItem(_Table, _KeyName, _KeyValue, _UpdateItem, out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction);
}
else
{
bResult = DatabaseService.PutItem(_Table, _KeyName, _KeyValue, _UpdateItem, out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction);
}
if (!bResult)
{
BroadcastFailed_FireAndForget_Operation(new Action_DeliveryEnsurer_DB_UpdateOrPutItem()
{
QueryType = _QueryType,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
UpdateItemStringified = _UpdateItem.ToString(),
RetryCount = _Current_Retry_Count
}, _ErrorMessageAction);
}
}
private static List <string> GetPodList()
{
MakeQueryParameters(out BMemoryQueryParameters QueryParameters, POD_LIST_KEY);
BPrimitiveType ListValue = MemoryService.GetKeyValue(QueryParameters, POD_LIST_KEY, (string Message) => { throw new Exception(Message); });
if (ListValue != null)
{
string ListJson = ListValue.AsString;
if (ListJson != null)
{
return(JsonConvert.DeserializeObject <List <string> >(ListJson));
}
else
{
return(new List <string>());
}
}
else
{
return(new List <string>());
}
}
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 void DB_DeleteItem_FireAndForget_Internal(
string _Table,
string _KeyName,
BPrimitiveType _KeyValue,
int _Current_RetryCount = 0,
Action <string> _ErrorMessageAction = null)
{
if (DatabaseService == null)
{
return;
}
if (!DatabaseService.DeleteItem(_Table, _KeyName, _KeyValue, out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction))
{
BroadcastFailed_FireAndForget_Operation(new Action_DeliveryEnsurer_DB_DeleteItem()
{
QueryType = Action_DeliveryEnsurer.QUERY_TYPE_DB_DELETE_ITEM,
TableName = _Table,
KeyName = _KeyName,
KeyValue = new BPrimitiveType_JStringified(_KeyValue),
RetryCount = _Current_RetryCount
}, _ErrorMessageAction);
}
}
private BWebServiceResponse GetUserInfo(Action <string> _ErrorMessageAction)
{
var UserKey = new BPrimitiveType(RequestedUserID);
if (!DatabaseService.GetItem(
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
UserKey,
UserDBEntry.GetableProperties,
out JObject UserObject,
_ErrorMessageAction))
{
return(BWebResponse.InternalError("Database fetch-user-info operation has failed."));
}
if (UserObject == null)
{
return(BWebResponse.NotFound("User does not exist."));
}
//Append id
UserObject[UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID;
return(BWebResponse.StatusOK("Get user information operation has succeeded.", UserObject));
}
public override BWebServiceResponse OnRequest_Interruptable(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (_Context.Request.HttpMethod != "POST")
{
_ErrorMessageAction?.Invoke("CheckModelsExist: 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;
try
{
using (var InputStream = _Context.Request.InputStream)
{
using var ResponseReader = new StreamReader(InputStream);
RequestPayload = ResponseReader.ReadToEnd();
ParsedBody = JObject.Parse(RequestPayload);
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("CheckModelsExist-> 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."));
}
//get UserModels from parsed request body
var UserModelIDs = new List <string>();
if (ParsedBody["userModelIds"].Type != JTokenType.Array)
{
return(BWebResponse.BadRequest("Request is invalid."));
}
var UserModelsJArray = (JArray)ParsedBody["userModelIds"];
foreach (var CurrentUserModelID in UserModelsJArray)
{
if (CurrentUserModelID.Type != JTokenType.String)
{
return(BWebResponse.BadRequest("Request is invalid."));
}
var UserModelID = (string)CurrentUserModelID;
if (!UserModelIDs.Contains(UserModelID))
{
UserModelIDs.Add(UserModelID);
}
}
//get UserSharedModels from parsed request body
var UserSharedModelIDs = new List <string>();
if (ParsedBody["userSharedModelIds"].Type != JTokenType.Array)
{
return(BWebResponse.BadRequest("Request is invalid."));
}
var UserSharedModelsJArray = (JArray)ParsedBody["userSharedModelIds"];
foreach (var CurrentUserSharedModelID in UserSharedModelsJArray)
{
if (CurrentUserSharedModelID.Type != JTokenType.String)
{
return(BWebResponse.BadRequest("Request is invalid."));
}
var UserSharedModelID = (string)CurrentUserSharedModelID;
if (!UserSharedModelIDs.Contains(UserSharedModelID))
{
UserSharedModelIDs.Add(UserSharedModelID);
}
}
var CheckedUserModelIDs = new JArray();
foreach (var ModelID in UserModelIDs)
{
var ModelKey = new BPrimitiveType(ModelID);
if (!CommonMethods.TryGettingModelInfo(
DatabaseService,
ModelID,
out JObject _,
true, out ModelDBEntry ModelData,
out BWebServiceResponse _FailedResponse,
_ErrorMessageAction))
{
if (_FailedResponse.StatusCode >= 400 && _FailedResponse.StatusCode < 500)
{
continue;
}
else if (_FailedResponse.StatusCode >= 500)
{
return(BWebResponse.InternalError("Getting user model info operation has been failed."));
}
}
if (!CheckedUserModelIDs.Contains(ModelID))
{
CheckedUserModelIDs.Add(ModelID);
}
}
var CheckedUserSharedModelIDs = new JArray();
foreach (var SharedModelID in UserSharedModelIDs)
{
var ModelKey = new BPrimitiveType(SharedModelID);
if (!CommonMethods.TryGettingModelInfo(
DatabaseService,
SharedModelID,
out JObject _,
true, out ModelDBEntry ModelData,
out BWebServiceResponse _FailedResponse,
_ErrorMessageAction))
{
if (_FailedResponse.StatusCode >= 400 && _FailedResponse.StatusCode < 500)
{
continue;
}
else if (_FailedResponse.StatusCode >= 500)
{
return(BWebResponse.InternalError("Getting user shared model info operation has been failed."));
}
}
if (!CheckedUserSharedModelIDs.Contains(SharedModelID))
{
CheckedUserSharedModelIDs.Add(SharedModelID);
}
}
return(BWebResponse.StatusOK("Check models have successfully been completed.", new JObject()
{
["checkedUserModelIds"] = CheckedUserModelIDs,
["checkedUserSharedModelIds"] = CheckedUserSharedModelIDs
}));
}
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."));
}
//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 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);
}
}
}
private BWebServiceResponse DeleteModel(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
if (!CommonMethods.TryGettingModelInfo(
DatabaseService,
RequestedModelID,
out JObject _,
true, out ModelDBEntry Model,
out BWebServiceResponse FailureResponse,
_ErrorMessageAction))
{
return(FailureResponse);
}
if (!Controller_AttributeTables.Get().AddRemoveMetadataSets_AttributesTables(
InnerDeliveryEnsurerUserProcessor, Model.ModelOwnerUserID,
Controller_AttributeTables.MetadataLocator.ItIsModelMetadata(RequestedModelID),
Model.ModelMetadata,
Controller_AttributeTables.EAddRemove.Remove,
Controller_AttributeTables.EKillProcedureIfGetClearanceFails.Yes,
out FailureResponse, _ErrorMessageAction))
{
return(FailureResponse);
}
foreach (var Rev in Model.ModelRevisions)
{
Controller_ModelActions.Get().BroadcastModelAction(new Action_ModelRevisionFileEntryDeleteAll
(
RequestedModelID,
Rev.RevisionIndex,
Model.ModelOwnerUserID,
Model.ModelSharedWithUserIDs,
AuthorizedUser.UserID,
JObject.Parse(JsonConvert.SerializeObject(Rev.FileEntry))
),
_ErrorMessageAction);
}
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(),
UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME,
new BPrimitiveType(Model.ModelName));
var RequestedModelIDPrimitive = new BPrimitiveType(RequestedModelID);
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
ModelDBEntry.DBSERVICE_MODELS_TABLE(),
ModelDBEntry.KEY_NAME_MODEL_ID,
RequestedModelIDPrimitive);
if (Model.ModelSharedWithUserIDs.Contains("*"))
{
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
GloballySharedModelIDsDBEntry.DBSERVICE_GLOBALLY_SHARED_MODEL_IDS_TABLE(),
GloballySharedModelIDsDBEntry.KEY_NAME_MODEL_ID,
RequestedModelIDPrimitive);
}
Controller_ModelActions.Get().BroadcastModelAction(new Action_ModelDeleted
(
RequestedModelID,
Model.ModelOwnerUserID,
Model.ModelSharedWithUserIDs,
AuthorizedUser.UserID
),
_ErrorMessageAction);
return(BWebResponse.StatusOK("Model has been deleted."));
}
protected void AddKeyToJson(Newtonsoft.Json.Linq.JObject Destination, string _KeyName, BPrimitiveType _KeyValue)
{
if (Destination != null && !Destination.ContainsKey(_KeyName))
{
Destination[_KeyName] = FromBPrimitiveTypeToJToken(_KeyValue);
}
}
private BWebServiceResponse CreateAccessMethodForUser(HttpListenerContext _Context, out bool _bSetClearanceForApiKey, out string _ApiKey, Action <string> _ErrorMessageAction)
{
_bSetClearanceForApiKey = false;
_ApiKey = null;
AuthMethod NewMethod = null;
using (var InputStream = _Context.Request.InputStream)
{
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
NewMethod = JsonConvert.DeserializeObject <AuthMethod>(ResponseReader.ReadToEnd());
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("User_CreateListAccessMethods_ForUser->CreateAccessMethodForUser: 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 (NewMethod == null)
{
return(BWebResponse.BadRequest("Request body does not contain all mandatory information or some fields are invalid."));
}
BPrimitiveType AuthMethodKey = null;
if (NewMethod.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD)
{
if (NewMethod.UserEmail == null || NewMethod.PasswordMD5 == null || NewMethod.UserEmail.Length == 0 || NewMethod.PasswordMD5.Length == 0)
{
return(BWebResponse.BadRequest("Request body does not contain all fields."));
}
AuthMethodKey = new BPrimitiveType(NewMethod.UserEmail + NewMethod.PasswordMD5);
}
else if (NewMethod.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD)
{
if (NewMethod.UserName == null || NewMethod.PasswordMD5 == null || NewMethod.UserName.Length == 0 || NewMethod.PasswordMD5.Length == 0)
{
return(BWebResponse.BadRequest("Request body does not contain all fields."));
}
AuthMethodKey = new BPrimitiveType(NewMethod.UserName + NewMethod.PasswordMD5);
}
else if (NewMethod.Method == AuthMethod.Methods.API_KEY_METHOD)
{
int ExistenceTrial = 0;
while (ExistenceTrial < 3)
{
if (!BUtility.CalculateStringMD5(BUtility.RandomString(32, false), out NewMethod.ApiKey, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Hashing error."));
}
NewMethod.ApiKey = NewMethod.ApiKey.ToUpper();
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + NewMethod.ApiKey, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Atomic operation control has failed."));
}
if (!DatabaseService.UpdateItem(
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_API_KEY,
new BPrimitiveType(NewMethod.ApiKey),
new JObject()
{
[UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID
},
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
DatabaseService.BuildAttributeNotExistCondition(UniqueUserFieldsDBEntry.KEY_NAME_API_KEY),
_ErrorMessageAction))
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + NewMethod.ApiKey, _ErrorMessageAction);
ExistenceTrial++;
}
else
{
_bSetClearanceForApiKey = true;
_ApiKey = NewMethod.ApiKey;
break;
}
}
private BWebServiceResponse UpdateUserInfo_Internal(
HttpListenerContext _Context,
string _NewEmailChange,
string _NewUserNameChange,
JObject _UserObject,
JObject _UpdateFieldsUserEntry, JObject _UpdateFieldsAuthEntry,
Action <string> _ErrorMessageAction)
{
var UserKey = new BPrimitiveType(RequestedUserID);
if (_UpdateFieldsUserEntry.Count > 0)
{
string OldEmail = null;
string OldUserName = null;
if (_NewEmailChange != null && _UserObject.ContainsKey(UserDBEntry.USER_EMAIL_PROPERTY))
{
OldEmail = (string)_UserObject[UserDBEntry.USER_EMAIL_PROPERTY];
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL,
new BPrimitiveType(OldEmail));
Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL,
new BPrimitiveType(_NewEmailChange),
new JObject()
{
[UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID
});
}
if (_NewUserNameChange != null && _UserObject.ContainsKey(UserDBEntry.USER_NAME_PROPERTY))
{
OldUserName = (string)_UserObject[UserDBEntry.USER_NAME_PROPERTY];
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME,
new BPrimitiveType(OldUserName));
Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME,
new BPrimitiveType(_NewUserNameChange),
new JObject()
{
[UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID
});
}
Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget(
_Context,
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
UserKey,
_UpdateFieldsUserEntry);
var NewEmail = _NewEmailChange ?? (string)_UserObject[UserDBEntry.USER_EMAIL_PROPERTY];
var NewUserName = _NewUserNameChange ?? (string)_UserObject[UserDBEntry.USER_NAME_PROPERTY];
Controller_UserActions.Get().BroadcastUserAction(new Action_UserUpdated(
RequestedUserID,
OldEmail ?? NewEmail,
NewEmail,
OldUserName ?? NewUserName,
NewUserName,
_UpdateFieldsUserEntry), _ErrorMessageAction);
}
if (_UpdateFieldsAuthEntry.Count > 0)
{
var UserData = JsonConvert.DeserializeObject <UserDBEntry>(_UserObject.ToString());
if (UserData.AuthMethods != null && UserData.AuthMethods.Count > 0)
{
foreach (var Method in UserData.AuthMethods)
{
string PasswordMD5 = null;
string OldField = null;
BPrimitiveType AuthMethodKey = null;
switch (Method.Method)
{
case AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD:
{
PasswordMD5 = Method.PasswordMD5;
OldField = Method.UserEmail;
AuthMethodKey = new BPrimitiveType(Method.UserEmail + PasswordMD5);
break;
}
case AuthMethod.Methods.USER_NAME_PASSWORD_METHOD:
{
PasswordMD5 = Method.PasswordMD5;
OldField = Method.UserName;
AuthMethodKey = new BPrimitiveType(Method.UserName + PasswordMD5);
break;
}
case AuthMethod.Methods.API_KEY_METHOD:
AuthMethodKey = new BPrimitiveType(Method.ApiKey);
break;
}
if (AuthMethodKey != null)
{
bool bRecreateNeed =
(_NewEmailChange != null && Method.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD) ||
(_NewUserNameChange != null && Method.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD);
if (bRecreateNeed)
{
MemoryService.DeleteKey(CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + AuthMethodKey.AsString, _ErrorMessageAction);
//No in-memory recreation for security.
if (!DatabaseService.DeleteItem(
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey,
out JObject DeletedAuthMethodObject,
EBReturnItemBehaviour.ReturnAllOld,
_ErrorMessageAction))
{
DatabaseService.GetItem(
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey,
AuthDBEntry.Properties,
out DeletedAuthMethodObject,
_ErrorMessageAction);
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey);
}
if (DeletedAuthMethodObject != null)
{
DeletedAuthMethodObject.Merge(_UpdateFieldsAuthEntry, new JsonMergeSettings()
{
MergeArrayHandling = MergeArrayHandling.Replace
});
_UpdateFieldsAuthEntry = DeletedAuthMethodObject;
}
if (_NewEmailChange != null && Method.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD)
{
AuthMethodKey = new BPrimitiveType(_NewEmailChange + PasswordMD5);
}
else if (_NewUserNameChange != null && Method.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD)
{
AuthMethodKey = new BPrimitiveType(_NewUserNameChange + PasswordMD5);
}
Controller_DeliveryEnsurer.Get().DB_PutItem_FireAndForget(
_Context,
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey,
_UpdateFieldsAuthEntry);
}
else
{
Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget(
_Context,
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey,
_UpdateFieldsAuthEntry);
}
}
}
}
}
return(BWebResponse.StatusOK("User has been updated."));
}
private BWebServiceResponse UpdateBaseRightForUser(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
var NewRights = new List <string>();
using (var InputStream = _Context.Request.InputStream)
{
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
var NewRightsArray = JArray.Parse(ResponseReader.ReadToEnd());
foreach (string NewRight in NewRightsArray)
{
var NewRightCaseCorrected = NewRight.ToUpper();
if (AccessScopeLibrary.ACCESS_RIGHTS.Contains(NewRightCaseCorrected))
{
NewRights.Add(NewRightCaseCorrected);
}
}
NewRights = NewRights.Distinct().ToList();
NewRights.Sort();
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("User_UpdateDeleteBaseRight_ForUser->UpdateBaseRightForUser: 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 (NewRights.Count == 0)
{
return(BWebResponse.BadRequest("Request does not contain any valid access right. Use DELETE method for deleting the 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."));
}
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 BaseAccessScopeAsList = new List <AccessScope>();
//Check existence of access scope
AccessScope ExistingAccessScope = null;
int ExistingAccessScopeIndex = -1;
int j = 0;
foreach (JObject BaseAccessScopeObject in BaseAccessScopeAsArray)
{
var Scope = JsonConvert.DeserializeObject <AccessScope>(BaseAccessScopeObject.ToString());
BaseAccessScopeAsList.Add(Scope);
if (ExistingAccessScopeIndex == -1 && Scope.WildcardPath == RequestedBaseRightWildcard)
{
ExistingAccessScope = Scope;
ExistingAccessScopeIndex = j;
}
j++;
}
if (ExistingAccessScopeIndex == -1)
{
return(BWebResponse.NotFound("User does not have the given base right."));
}
ExistingAccessScope.AccessRights.Sort();
//Check if requested rights are different
bool bDifferent = false;
if (ExistingAccessScope.AccessRights.Count == NewRights.Count)
{
for (var i = 0; i < ExistingAccessScope.AccessRights.Count; i++)
{
if (ExistingAccessScope.AccessRights[i] != NewRights[i])
{
bDifferent = true;
break;
}
}
}
else
{
bDifferent = true;
}
if (bDifferent)
{
ExistingAccessScope.AccessRights = NewRights;
BaseAccessScopeAsArray[ExistingAccessScopeIndex] = JObject.Parse(JsonConvert.SerializeObject(ExistingAccessScope));
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 = BaseAccessScopeAsList
})))
}, _ErrorMessageAction);
}
return(BWebResponse.StatusOK("Base right has been updated."));
}
private BWebServiceResponse DeleteUser(HttpListenerContext _Context, out bool _bSetClearanceForApiKeys, out List <string> _ApiKeys, Action <string> _ErrorMessageAction)
{
_bSetClearanceForApiKeys = false;
_ApiKeys = new List <string>();
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 UserData = JsonConvert.DeserializeObject <UserDBEntry>(UserObject.ToString());
if (UserData.AuthMethods != null && UserData.AuthMethods.Count > 0)
{
foreach (var AMethod in UserData.AuthMethods)
{
string OldField = null;
BPrimitiveType AuthMethodKey = null;
switch (AMethod.Method)
{
case AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD:
{
AuthMethodKey = new BPrimitiveType(AMethod.UserEmail + AMethod.PasswordMD5);
OldField = AMethod.UserEmail;
break;
}
case AuthMethod.Methods.USER_NAME_PASSWORD_METHOD:
{
AuthMethodKey = new BPrimitiveType(AMethod.UserName + AMethod.PasswordMD5);
OldField = AMethod.UserName;
break;
}
case AuthMethod.Methods.API_KEY_METHOD:
{
AuthMethodKey = new BPrimitiveType(AMethod.ApiKey);
_bSetClearanceForApiKeys = true;
_ApiKeys.Add(AMethod.ApiKey);
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + AMethod.ApiKey, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Atomic operation control has failed."));
}
break;
}
}
if (AuthMethodKey != null)
{
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
AuthMethodKey);
MemoryService.DeleteKey(CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + AuthMethodKey.AsString, _ErrorMessageAction);
}
}
}
MemoryService.DeleteKey(CommonData.MemoryQueryParameters, UserBaseAccessMEntry.M_KEY_NAME_USER_ID + RequestedUserID, _ErrorMessageAction);
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
UserKey);
Controller_UserActions.Get().BroadcastUserAction(new Action_UserDeleted
(
RequestedUserID,
UserData.UserEmail,
UserData.UserName,
UserData.UserModels,
UserData.UserSharedModels
),
_ErrorMessageAction);
if (UserData.UserEmail != null && UserData.UserEmail.Length > 0)
{
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL,
new BPrimitiveType(UserData.UserEmail));
}
if (UserData.UserName != null && UserData.UserName.Length > 0)
{
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME,
new BPrimitiveType(UserData.UserName));
}
foreach (var ApiKey in _ApiKeys)
{
Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget(
_Context,
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_API_KEY,
new BPrimitiveType(ApiKey));
}
return(BWebResponse.StatusOK("User has been deleted."));
}
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."));
}
