private void PreCleanup()
{
SelectedDBService.DeleteItem(
TableName,
Key, new BPrimitiveType("test_1"),
out JObject Ignore,
EBReturnItemBehaviour.DoNotReturn,
null);
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
//GET is supported for easy calls from terraform scripts since it only has GET request support out of the box.
//https://www.terraform.io/docs/providers/http/data_source.html
//POST calls are recommended to use over GET.
if (_Context.Request.HttpMethod != "DELETE")
{
_ErrorMessageAction?.Invoke("ScheduleRequest: DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod);
return(BWebResponse.MethodNotAllowed("DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod));
}
JObject ParsedBody = null;
if (_Context.Request.HttpMethod == "DELETE")
{
using (var InputStream = _Context.Request.InputStream)
{
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
ParsedBody = JObject.Parse(ResponseReader.ReadToEnd());
}
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 (!ParsedBody.ContainsKey(ScheduledUrlTaskDBEntry.URL_PROPERTY) ||
ParsedBody[ScheduledUrlTaskDBEntry.URL_PROPERTY].Type != JTokenType.String)
{
return(BWebResponse.BadRequest("Request must contain all necessary fields validly. Given argument: " + ParsedBody.ToString()));
}
string Url = (string)ParsedBody[ScheduledUrlTaskDBEntry.URL_PROPERTY];
if (!Uri.TryCreate(Url, UriKind.Absolute, out Uri UriResult) ||
(UriResult.Scheme != Uri.UriSchemeHttp && UriResult.Scheme != Uri.UriSchemeHttps))
{
return(BWebResponse.BadRequest("Given field " + ScheduledUrlTaskDBEntry.URL_PROPERTY + " is invalid. Given argument: " + ParsedBody.ToString()));
}
if (!DatabaseService.DeleteItem(
ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(),
ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL,
new BPrimitiveType(WebUtility.UrlEncode(Url)),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
_ErrorMessageAction))
{
return(BWebResponse.InternalError("Database delete operation has failed."));
}
return(BWebResponse.StatusOK("Task has been unscheduled."));
}
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 void SecondCheck(HttpListenerContext _Context, List <ScheduledUrlTaskDBEntry> _URLTasks, Action <string> _ErrorMessageAction)
{
var WaitUntil = new ManualResetEvent(false);
var Counter = new ConcurrentStack <bool>();
var DeleteItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>();
var FailedItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>();
var UpdateItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>();
var TimeHasComeFor = new List <ScheduledUrlTaskDBEntry>();
foreach (var URLTask in _URLTasks)
{
if (URLTask.ScheduledToTime < new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds())
{
TimeHasComeFor.Add(URLTask);
Counter.Push(true);
}
}
foreach (var Current in TimeHasComeFor)
{
var Process = Current;
BTaskWrapper.Run(() =>
{
var bRequestSuccess = PerformHttpRequest(out int StatusCode, Process.Url, Process.Verb, Process.Headers, Process.Body, _ErrorMessageAction);
bool bDeleted = false;
foreach (int CancelReturnCode in Process.CancelOnReturnCodes)
{
if (CancelReturnCode == StatusCode)
{
bDeleted = true;
DeleteItems.Enqueue(Process);
break;
}
}
if (!bDeleted)
{
if (bRequestSuccess)
{
if (Process.bCancelRetryOnSuccess)
{
DeleteItems.Enqueue(Process);
}
else
{
if (Process.RetryCount == -1 ||
(Process.RetriedCount + 1) <= Process.RetryCount)
{
UpdateItems.Enqueue(Process);
}
else
{
DeleteItems.Enqueue(Process);
}
}
}
else
{
FailedItems.Enqueue(Process);
}
}
Counter.TryPop(out bool _);
if (Counter.IsEmpty)
{
try
{
WaitUntil.Set();
}
catch (Exception) { }
}
});
}
try
{
if (TimeHasComeFor.Count > 0)
{
WaitUntil.WaitOne();
}
WaitUntil.Close();
}
catch (Exception) { }
while (FailedItems.TryDequeue(out ScheduledUrlTaskDBEntry Failed))
{
if (Failed.RetryCount == -1 ||
(Failed.RetriedCount + 1) <= Failed.RetryCount)
{
Failed.RetriedCount++;
Failed.ScheduledToTime = new DateTimeOffset(DateTime.UtcNow.AddSeconds(Failed.RetryInSeconds)).ToUnixTimeSeconds();
DatabaseService.UpdateItem(
ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(),
ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL,
new BPrimitiveType(WebUtility.UrlEncode(Failed.Url)),
JObject.Parse(JsonConvert.SerializeObject(Failed)),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
null,
_ErrorMessageAction);
}
else
{
DeleteItems.Enqueue(Failed);
}
}
while (UpdateItems.TryDequeue(out ScheduledUrlTaskDBEntry Update))
{
Update.RetriedCount++;
Update.ScheduledToTime = new DateTimeOffset(DateTime.UtcNow.AddSeconds(Update.RetryInSeconds)).ToUnixTimeSeconds();
DatabaseService.UpdateItem(
ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(),
ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL,
new BPrimitiveType(WebUtility.UrlEncode(Update.Url)),
JObject.Parse(JsonConvert.SerializeObject(Update)),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
null,
_ErrorMessageAction);
}
while (DeleteItems.TryDequeue(out ScheduledUrlTaskDBEntry Delete))
{
DatabaseService.DeleteItem(
ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(),
ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL,
new BPrimitiveType(WebUtility.UrlEncode(Delete.Url)),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
_ErrorMessageAction);
}
}
private void Cleanup_UniqueFileFields(Action <string> _ErrorMessageAction)
{
if (!DatabaseService.ScanTable(
UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(),
out List <JObject> UniqueFieldsEntries,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("Cleanup_UniqueFileFields: Table does not exist or ScanTable operation has failed.");
return;
}
if (UniqueFieldsEntries.Count == 0)
{
return;
}
foreach (var Current in UniqueFieldsEntries)
{
if (!Current.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID))
{
continue;
}
if (!Current.ContainsKey(UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME))
{
continue;
}
var ModelUniqueName = (string)Current[UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME];
var ModelID = (string)Current[ModelDBEntry.KEY_NAME_MODEL_ID];
var Casted = JsonConvert.DeserializeObject <UniqueFileFieldsDBEntry>(Current.ToString());
try
{
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction))
{
continue;
}
bool bDeleteEntry = false;
if (!DatabaseService.GetItem(
ModelDBEntry.DBSERVICE_MODELS_TABLE(),
ModelDBEntry.KEY_NAME_MODEL_ID,
new BPrimitiveType(ModelID),
ModelDBEntry.Properties,
out JObject ModelObject,
_ErrorMessageAction))
{
continue;
}
if (ModelObject == null)
{
//Model does not exist
bDeleteEntry = true;
}
else
{
var Model = JsonConvert.DeserializeObject <ModelDBEntry>(ModelObject.ToString());
bDeleteEntry = ModelUniqueName != Model.ModelName;
}
if (bDeleteEntry)
{
DatabaseService.DeleteItem(
UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(),
UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME,
new BPrimitiveType(ModelUniqueName),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
_ErrorMessageAction);
}
}
finally
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction);
}
}
}
private BWebServiceResponse 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 void Cleanup_AuthMethods(Action <string> _ErrorMessageAction = null)
{
if (!DatabaseService.ScanTable(
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
out List <JObject> AuthEntries,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Table does not exist or ScanTable operation has failed.");
return;
}
if (AuthEntries.Count == 0)
{
return;
}
foreach (var Current in AuthEntries)
{
var Casted = JsonConvert.DeserializeObject <AuthDBEntry>(Current.ToString());
var EntryKey = (string)Current[AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY];
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction))
{
continue;
}
try
{
bool bDeleteEntry = false;
if (!DatabaseService.GetItem(
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
new BPrimitiveType(Casted.UserID),
UserDBEntry.Properties,
out JObject UserObject,
_ErrorMessageAction))
{
continue;
}
if (UserObject == null)
{
//User does not exist
bDeleteEntry = true;
}
else
{
bool bFound = false;
bool bSSOMethod = false;
bool bSSORefreshTokenExpired = false;
var User = JsonConvert.DeserializeObject <UserDBEntry>(UserObject.ToString());
for (var i = 0; i < User.AuthMethods.Count; i++)
{
var UserAuthMethod = User.AuthMethods[i];
var UserAuthMethodKey = "";
if (UserAuthMethod.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD)
{
if (UserAuthMethod.UserEmail == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserEmail.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0)
{
continue;
}
UserAuthMethodKey = UserAuthMethod.UserEmail + UserAuthMethod.PasswordMD5;
if (UserAuthMethodKey == EntryKey)
{
bFound = true;
//SSO Auth Method Expiry Check
if (UserAuthMethod.UserEmail.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX))
{
bSSOMethod = true;
var QueryParameters = Controller_SSOAccessToken.MakeSSOQueryParameters(UserAuthMethod.PasswordMD5);
if (Controller_SSOAccessToken.IsTokenExpiredOrInvalid(out Dictionary <string, BPrimitiveType> _Result, MemoryService, QueryParameters, _ErrorMessageAction) ||
_Result == null)
{
bSSORefreshTokenExpired = true;
User.AuthMethods.RemoveAt(i);
}
}
break;
}
}
else
{
if (UserAuthMethod.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD)
{
if (UserAuthMethod.UserName == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserName.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0)
{
continue;
}
UserAuthMethodKey = UserAuthMethod.UserName + UserAuthMethod.PasswordMD5;
}
else if (UserAuthMethod.Method == AuthMethod.Methods.API_KEY_METHOD)
{
UserAuthMethodKey = UserAuthMethod.ApiKey;
}
if (UserAuthMethodKey == EntryKey)
{
bFound = true;
break;
}
}
}
if (!bFound)
{
bDeleteEntry = true;
}
else if (bSSOMethod && bSSORefreshTokenExpired)
{
_ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Expired sso auth method has been found. Deleting the entry.");
bDeleteEntry = true;
DatabaseService.UpdateItem(
UserDBEntry.DBSERVICE_USERS_TABLE(),
UserDBEntry.KEY_NAME_USER_ID,
new BPrimitiveType(Casted.UserID),
JObject.Parse(JsonConvert.SerializeObject(User)),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
null,
_ErrorMessageAction);
}
}
if (bDeleteEntry)
{
DatabaseService.DeleteItem(
AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(),
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY,
new BPrimitiveType(EntryKey),
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
_ErrorMessageAction);
MemoryService.DeleteKey(
CommonData.MemoryQueryParameters,
AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + EntryKey,
_ErrorMessageAction);
}
}
finally
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction);
}
}
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
if (_Context.Request.HttpMethod != "POST")
{
_ErrorMessageAction?.Invoke("StopProcessRequest: POST methods is accepted. But received request method: " + _Context.Request.HttpMethod);
return(BWebResponse.MethodNotAllowed("POST methods is accepted. But received request method: " + _Context.Request.HttpMethod));
}
string BucketName = null;
string RelativeFilename = null;
string ConversionID_FromRelativeUrl_UrlEncoded = null;
using (var InputStream = _Context.Request.InputStream)
{
var NewObjectJson = new JObject();
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd());
if (!ParsedBody.ContainsKey("bucketName") ||
!ParsedBody.ContainsKey("rawFileRelativeUrl"))
{
return(BWebResponse.BadRequest("Request body must contain all necessary fields."));
}
var BucketNameToken = ParsedBody["bucketName"];
var RawFileRelativeUrlToken = ParsedBody["rawFileRelativeUrl"];
if (BucketNameToken.Type != JTokenType.String ||
RawFileRelativeUrlToken.Type != JTokenType.String)
{
return(BWebResponse.BadRequest("Request body contains invalid fields."));
}
BucketName = (string)BucketNameToken;
ConversionID_FromRelativeUrl_UrlEncoded = WebUtility.UrlEncode((string)RawFileRelativeUrlToken);
RelativeFilename = (string)RawFileRelativeUrlToken;
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace);
return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form."));
}
}
}
//Temporarily, TODO: Change this when the implementation is in place.
if (!DatabaseService.DeleteItem(
FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(),
FileConversionDBEntry.KEY_NAME_CONVERSION_ID,
new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded),
out JObject _, EBReturnItemBehaviour.DoNotReturn,
_ErrorMessageAction))
{
if (!DatabaseService.GetItem(
FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(),
FileConversionDBEntry.KEY_NAME_CONVERSION_ID,
new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded),
FileConversionDBEntry.Properties,
out JObject _ReturnObject,
_ErrorMessageAction) ||
_ReturnObject != null)
{
return(BWebResponse.InternalError("Database error."));
}
}
if (!BatchProcessingCreationService.Instance.StopBatchProcess(BucketName, RelativeFilename, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Failed to stop pod or connect to kubernetess"));
}
return(BWebResponse.StatusAccepted("Request has been accepted; process is now being stopped."));
}
