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 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);
}
}
}
public bool Start()
{
PrintAction?.Invoke("BDatabaseServicesTest->Info-> Test is starting.");
if (SelectedDBService == null)
{
PrintAction?.Invoke("BDatabaseServicesTest->Error-> Given SelectedDBService is null.");
return(false);
}
if (TableName == null || TableName.Length == 0)
{
PrintAction?.Invoke("BDatabaseServicesTest->Error-> Given TableName is null or empty.");
return(false);
}
if (Key == null || Key.Length == 0)
{
PrintAction?.Invoke("BDatabaseServicesTest->Error-> Given Key is null or empty.");
return(false);
}
if (!SelectedDBService.HasInitializationSucceed())
{
PrintAction?.Invoke("BDatabaseServicesTest->Error-> Initialization failed.");
return(false);
}
PrintAction?.Invoke("BDatabaseServicesTest->Log-> Initialization succeed.");
PreCleanup();
if (!TestPutItem(1))
{
return(false);
}
PrintAction?.Invoke("BDatabaseServicesTest->Log-> Conditional put item, expecting failure.");
if (TestPutItem(2, SelectedDBService.BuildAttributeNotExistCondition(Key)))
{
return(false);
}
if (!TestGetItem(3))
{
return(false);
}
if (!TestUpdateItem(4))
{
return(false);
}
PrintAction?.Invoke("BDatabaseServicesTest->Log-> Conditional update item, expecting failure.");
if (TestUpdateItem(5,
SelectedDBService.BuildAttributeEqualsCondition("Test_Attr_Key_2", new BPrimitiveType(345))))
{
return(false);
}
if (!TestUpdateItem(6,
SelectedDBService.BuildAttributeNotEqualsCondition("Test_Attr_Key_2", new BPrimitiveType(345))))
{
return(false);
}
if (!TestUpdateItem(7,
SelectedDBService.BuildAttributeGreaterOrEqualCondition("Test_Attr_Key_2", new BPrimitiveType(22))))
{
return(false);
}
if (!TestUpdateItem(8,
SelectedDBService.BuildAttributeGreaterCondition("Test_Attr_Key_2", new BPrimitiveType(21))))
{
return(false);
}
if (!TestUpdateItem(9,
SelectedDBService.BuildAttributeLessCondition("Test_Attr_Key_2", new BPrimitiveType(23))))
{
return(false);
}
if (!TestUpdateItem(10,
SelectedDBService.BuildAttributeLessOrEqualCondition("Test_Attr_Key_2", new BPrimitiveType(22))))
{
return(false);
}
if (TestUpdateItem(11,
SelectedDBService.BuildAttributeEqualsCondition("Test_Attr_Key_1", new BPrimitiveType("Test_Attr_Val_New_2"))))
{
return(false);
}
if (TestUpdateItem(12,
SelectedDBService.BuildAttributeNotEqualsCondition("Test_Attr_Key_1", new BPrimitiveType("Test_Attr_Val_New_1"))))
{
return(false);
}
if (!TestUpdateItem(13,
SelectedDBService.BuildAttributeEqualsCondition("Test_Attr_Key_1", new BPrimitiveType("Test_Attr_Val_New_1"))))
{
return(false);
}
if (!TestUpdateItem(14, null, true))
{
return(false);
}
if (!TestGetItem(15))
{
return(false);
}
if (!TestIncrement(16))
{
return(false);
}
if (!TestScanTable(17))
{
return(false);
}
if (!TestDeleteItem(18))
{
return(false);
}
if (!TestAddToList(19))
{
return(false);
}
if (!TestRemoveFromList(20))
{
return(false);
}
return(true);
}
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
}));
}
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"));
}
}
