//================================================================================= Manage applications
public static Application RegisterApplication(RegisterApplicationRequest request)
{
using (var cn = new SqlConnection(Configuration.ConnectionString))
{
SqlCommand cm1 = null;
try
{
cn.Open();
cm1 = cn.CreateCommand();
cm1.CommandText = REGISTERAPPLICATIONSQL;
cm1.Connection = cn;
cm1.CommandType = CommandType.Text;
var appData = JsonConvert.SerializeObject(new
{
ApplicationUrl = request.ApplicationUrl,
TaskFinalizeUrl = request.TaskFinalizeUrl,
AuthenticationUrl = request.AuthenticationUrl,
AuthorizationUrl = request.AuthorizationUrl
});
var resultApp = new Application
{
AppId = request.AppId,
ApplicationUrl = request.ApplicationUrl,
AuthenticationUrl = request.AuthenticationUrl,
AuthorizationUrl = request.AuthorizationUrl
};
cm1.Parameters.Add("@AppId", SqlDbType.NVarChar).Value = request.AppId;
cm1.Parameters.Add("@AppData", SqlDbType.NVarChar).Value = appData;
using (var reader = cm1.ExecuteReader())
{
// there must be only one row
reader.Read();
resultApp.RegistrationDate = reader.GetDateTime(reader.GetOrdinal("RegistrationDate"));
resultApp.LastUpdateDate = reader.GetDateTime(reader.GetOrdinal("LastUpdateDate"));
}
return(resultApp);
}
catch (Exception ex)
{
SnLog.WriteException(ex, "Error during app registration.", EventId.TaskManagement.General);
throw new TaskManagementException("Error during application registration.", request.AppId, ex);
}
finally
{
if (cm1 != null)
{
cm1.Dispose();
}
}
}
}
/// <summary>
/// Registers an application through the task management API.
/// </summary>
/// <returns>Returns true if the registration was successful.</returns>
public static bool RegisterApplication()
{
var taskManUrl = Url;
if (string.IsNullOrEmpty(taskManUrl))
{
return(false);
}
var requestData = new RegisterApplicationRequest
{
AppId = ContentRepository.Storage.Settings.GetValue(Settings.SETTINGSNAME, Settings.TASKMANAGEMENTAPPID, null, Settings.TASKMANAGEMENTDEFAULTAPPID),
ApplicationUrl = ContentRepository.Storage.Settings.GetValue <string>(Settings.SETTINGSNAME, Settings.TASKMANAGEMENTAPPLICATIONURL)
};
// make this a synchron call
var registered = Instance.RegisterApplicationAsync(taskManUrl, requestData).GetAwaiter().GetResult();
if (registered)
{
SnLog.WriteInformation("Task management app registration was successful.", EventId.TaskManagement.General, properties: new Dictionary <string, object>
{
{ "TaskManagementUrl", taskManUrl },
{ "AppId", requestData.AppId }
});
}
return(registered);
}
public async Task <CreateApplicationResponse> Register(RegisterApplicationRequest o)
{
var result = new CreateApplicationResponse(o.RequestId);
result.Id = await Server.Register(o.Name, o.Description);
return(result);
}
public void RegisterApplication(RegisterApplicationRequest appRequest)
{
try
{
var app = TaskDataHandler.RegisterApplication(appRequest);
}
catch (Exception ex)
{
// the client app needs to be notified
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
// invalidate app cache
ApplicationHandler.Reset();
}
public virtual async Task <bool> RegisterApplicationAsync(CancellationToken cancellationToken)
{
var taskManagementUrl = _options.GetUrlOrSetting();
if (string.IsNullOrEmpty(taskManagementUrl))
{
SnTrace.TaskManagement.Write("Task management url is empty, application is not registered.");
return(false);
}
var requestData = new RegisterApplicationRequest
{
AppId = _options.GetApplicationIdOrSetting(),
ApplicationUrl = _options.GetApplicationUrlOrSetting()
};
try
{
await _client.RegisterApplicationAsync(requestData).ConfigureAwait(false);
SnLog.WriteInformation("Task management app registration was successful.", EventId.TaskManagement.General, properties: new Dictionary <string, object>
{
{ "TaskManagementUrl", taskManagementUrl },
{ "AppId", requestData.AppId }
});
return(true);
}
catch (Exception ex)
{
SnLog.WriteException(ex, "Error during app registration.", EventId.TaskManagement.General,
properties: new Dictionary <string, object>
{
{ "TaskManagementUrl", taskManagementUrl },
{ "AppId", requestData.AppId },
{ "ApplicationUrl", requestData.ApplicationUrl }
});
}
// no need to throw an exception, we already logged the error
return(false);
}
public async Task <RegisterApplicationResult> RegisterApplication([FromBody] RegisterApplicationRequest appRequest)
{
try
{
var _ = await _dataHandler.RegisterApplicationAsync(appRequest, HttpContext.RequestAborted)
.ConfigureAwait(false);
}
catch (Exception ex)
{
SnLog.WriteException(ex, $"Error during app registration. AppId: {appRequest?.AppId}, " +
$"Url: {appRequest?.ApplicationUrl}");
return(new RegisterApplicationResult
{
Success = false,
Error = ex.Message
});
}
// invalidate app cache
_applicationHandler.Reset();
return(new RegisterApplicationResult());
}
public virtual async Task <bool> RegisterApplicationAsync(string taskManagementUrl, RegisterApplicationRequest requestData)
{
try
{
await RepositoryClient.RegisterApplicationAsync(taskManagementUrl, requestData).ConfigureAwait(false);
return(true);
}
catch (Exception ex)
{
SnLog.WriteException(ex, "Error during app registration.", EventId.TaskManagement.General,
properties: new Dictionary <string, object>
{
{ "TaskManagementUrl", taskManagementUrl },
{ "AppId", requestData.AppId },
{ "ApplicationUrl", requestData.ApplicationUrl }
});
}
// no need to throw an exception, we already logged the error
return(false);
}