/// <inheritdoc/>
public Task OnApplicationUpdatedAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
using (_metrics.TrackDuration(nameof(OnApplicationUpdatedAsync))) {
return(CheckApplicationInfoAsync(application));
}
}
/// <summary>
/// Create model from service model
/// </summary>
/// <param name="model"></param>
public ApplicationInfoApiModel(ApplicationInfoModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ApplicationId = model.ApplicationId;
ApplicationType = model.ApplicationType;
ApplicationUri = model.ApplicationUri;
ApplicationName = model.ApplicationName;
Locale = model.Locale;
LocalizedNames = model.LocalizedNames;
Certificate = model.Certificate;
ProductUri = model.ProductUri;
SiteId = model.SiteId;
HostAddresses = model.HostAddresses;
SupervisorId = model.SupervisorId;
DiscoveryProfileUri = model.DiscoveryProfileUri;
DiscoveryUrls = model.DiscoveryUrls;
Capabilities = model.Capabilities;
NotSeenSince = model.NotSeenSince;
State = model.State;
GatewayServerUri = model.GatewayServerUri;
Created = model.Created == null ? null :
new RegistryOperationApiModel(model.Created);
Approved = model.Created == null ? null :
new RegistryOperationApiModel(model.Approved);
Updated = model.Created == null ? null :
new RegistryOperationApiModel(model.Updated);
}
/// <summary>
/// Create api model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static ApplicationInfoApiModel ToApiModel(
this ApplicationInfoModel model)
{
if (model == null)
{
return(null);
}
return(new ApplicationInfoApiModel {
ApplicationId = model.ApplicationId,
ApplicationType = (IIoT.OpcUa.Api.Registry.Models.ApplicationType)model.ApplicationType,
ApplicationUri = model.ApplicationUri,
ApplicationName = model.ApplicationName,
Locale = model.Locale,
LocalizedNames = model.LocalizedNames,
Certificate = model.Certificate,
ProductUri = model.ProductUri,
SiteId = model.SiteId,
HostAddresses = model.HostAddresses,
DiscovererId = model.DiscovererId,
DiscoveryProfileUri = model.DiscoveryProfileUri,
DiscoveryUrls = model.DiscoveryUrls,
Capabilities = model.Capabilities,
NotSeenSince = model.NotSeenSince,
GatewayServerUri = model.GatewayServerUri,
Created = model.Created.ToApiModel(),
Updated = model.Updated.ToApiModel(),
});
}
public ActionResult Return()
{
ApplicationInfoModel sm = (ApplicationInfoModel)Session["書類申請"];
sm.Find();
sm.SortAll();
sm.GetPage();
return(View("ApplicationManage", sm));
}
public ActionResult ApproveDataGet(string 申請ID)
{
ApplicationInfoModel smInfo = (ApplicationInfoModel)Session["書類申請"];
ApplicationApproveModel sm = new ApplicationApproveModel();
sm = sm.GetApproveData(smInfo, 申請ID);
Session["申請内容承認用"] = sm;
return(Json(new { result = "Success" }));
}
public ActionResult MovePage(int 新規ページ数)
{
ApplicationInfoModel sm = (ApplicationInfoModel)Session["書類申請"];
sm.現ページ = 新規ページ数;
sm.SortAll();
sm.GetPage();
Session["書類申請"] = sm;
return(PartialView("_ApplicationList", sm));
}
/// <summary>
/// Update application in index
/// </summary>
/// <param name="application"></param>
/// <param name="noAdd"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task UpdateAsync(ApplicationInfoModel application,
bool noAdd = false, CancellationToken ct = default)
{
try {
await _database.UpdateAsync(application.ApplicationId,
(existing, d) => {
existing.Patch(application);
return(true, d);
}, ct);
}
public ActionResult GetPage(ApplicationInfoModel m)
{
ApplicationInfoModel sm = (ApplicationInfoModel)Session["書類申請"];
sm.表示件数 = m.表示件数;
sm.現ページ = 1;
sm.SortAll();
sm.GetPage();
Session["書類申請"] = sm;
return(PartialView("_ApplicationList", sm));
}
/// <summary>
/// Create application event
/// </summary>
/// <param name="type"></param>
/// <param name="context"></param>
/// <param name="applicationId"></param>
/// <param name="application"></param>
/// <returns></returns>
private static ApplicationEventModel Wrap(ApplicationEventType type,
RegistryOperationContextModel context, string applicationId,
ApplicationInfoModel application)
{
return(new ApplicationEventModel {
EventType = type,
Context = context,
Id = applicationId,
Application = application
});
}
/// <summary>
/// Send application alert
/// </summary>
/// <param name="application"></param>
/// <param name="message"></param>
/// <param name="usedConfiguration"></param>
/// <returns></returns>
private Task SendApplicationAlertAsync(ApplicationInfoModel application,
string message, string usedConfiguration)
{
#if !USE_APPLICATION_IDENTITY
var deviceId = DiscovererModelEx.ParseDeviceId(
application.DiscovererId, out var moduleId);
#else
var deviceId = application.ApplicationId;
var moduleId = (string)null;
#endif
return(SendAlertAsync(deviceId, moduleId, message, usedConfiguration,
FlattenToDict(application)));
}
/// <summary>
/// Send application alert
/// </summary>
/// <param name="application"></param>
/// <param name="message"></param>
/// <returns></returns>
private Task SendApplicationAlertAsync(ApplicationInfoModel application,
string message)
{
#if !USE_APPLICATION_IDENTITY
var deviceId = SupervisorModelEx.ParseDeviceId(
application.SupervisorId, out var moduleId);
#else
var deviceId = application.ApplicationId;
var moduleId = (string)null;
#endif
return(SendAlertAsync(deviceId, moduleId, message,
FlattenToDict(application)));
}
public ApplicationInfoDTO GetInfo(Guid id)
{
List <ApplicationInfoModel> allApplicationInfoModes = _applicationManage.GetAllList();
ApplicationInfoModel applicationInfo = allApplicationInfoModes.FirstOrDefault(m => m.ID == id);
if (applicationInfo == null)
{
throw new DeployException("应用程序不存在");
}
var result = _mapper.Map <ApplicationInfoDTO>(applicationInfo);
return(result);
}
/// <summary>
/// Helper to assert the application model data which should remain equal.
/// </summary>
/// <param name="expected">The expected Application model data</param>
/// <param name="actual">The actualy Application model data</param>
public static void AssertEqualApplicationModelData(ApplicationInfoModel expected, ApplicationInfoModel actual)
{
Assert.Equal(expected.ApplicationName, actual.ApplicationName);
Assert.Equal(expected.ApplicationType, actual.ApplicationType);
Assert.Equal(expected.ApplicationUri, actual.ApplicationUri);
Assert.Equal(expected.DiscoveryProfileUri, actual.DiscoveryProfileUri);
Assert.Equal(expected.ProductUri, actual.ProductUri);
Assert.True(expected.Capabilities.SetEqualsSafe(actual.Capabilities),
ApplicationDocumentEx.GetServerCapabilitiesAsString(expected.Capabilities) + " != " +
ApplicationDocumentEx.GetServerCapabilitiesAsString(actual.Capabilities));
Assert.Equal(JsonConvert.SerializeObject(expected.LocalizedNames), JsonConvert.SerializeObject(actual.LocalizedNames));
Assert.Equal(JsonConvert.SerializeObject(expected.DiscoveryUrls), JsonConvert.SerializeObject(actual.DiscoveryUrls));
}
public ActionResult Sort(string ソート列, string ソート順)
{
ApplicationInfoModel sm = (ApplicationInfoModel)Session["書類申請"];
sm.ソート順 = ソート順;
sm.ソート列 = ソート列;
sm.現ページ = 1;
//sm.Find();
sm.SortAll();
sm.GetPage();
Session["書類申請"] = sm;
return(PartialView("_ApplicationList", sm));
}
public void Add(ApplicationInfoModel model)
{
if (_allApplicationInfos.ContainsKey(model.ID))
{
throw new DeployException("应用程序已存在");
}
model.ApplicationStatus = ApplicationStatusEnum.Stop;
var runtimeModel = new ApplicationRuntimeModel(model, _applicationHandlerContext);
if (!_allApplicationInfos.TryAdd(model.ID, runtimeModel))
{
throw new DeployException("添加失败");
}
}
public LoadApplicationInfo(int customerID, long?cashRequestID, DateTime?now)
{
this.customerID = customerID;
this.cashRequestID = cashRequestID;
this.now = now ?? DateTime.UtcNow;
this.loanTypes = new List <LoanTypeModel>();
this.discountPlans = new List <DiscountPlanModel>();
this.loanSources = new List <LoanSourceModel>();
Result = new ApplicationInfoModel {
AutomationOfferModel = new AutomationOfferModel(),
};
} // constructor
/// <summary>
/// Add application
/// </summary>
/// <param name="application"></param>
/// <param name="noUpdate"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task AddAsync(ApplicationInfoModel application,
bool noUpdate = false, CancellationToken ct = default)
{
try {
await _database.AddAsync(application, null, ct);
}
catch (ConflictingResourceException) when(!noUpdate)
{
await UpdateAsync(application, true, ct);
}
catch (Exception ex) {
_logger.Error(ex, "Failed to add application to index");
}
}
public void Edit(ApplicationInfoModel model)
{
if (!_allApplicationInfos.ContainsKey(model.ID))
{
throw new DeployException("应用程序不存在");
}
ApplicationRuntimeModel runtimeModel = _allApplicationInfos[model.ID];
if (runtimeModel.ApplicationStatus != ApplicationStatusEnum.Stop)
{
throw new DeployException("应用程序尚未停止");
}
model.ApplicationStatus = ApplicationStatusEnum.Stop;
model.CopyProperties(runtimeModel.ApplicationInfo);
}
//全体的にいろんな書き方と設計を試しています
//なんだかんだ引数の割の良さは感じますね。
//たぶん、フォーム側のマッピングモデルで持てるかどうかがコツかな。
//あとはフォームのマッピングモデルとかをきれいな命名規則で纏めて、
//完全に分離させる感じにするとキレイになるかもしれない。
//まあいろいろ試せばわかってくるかな。
//今回のはあんまりきれいにならなかった。
//状態をクラスに保持して、プロパティはviewからマッピングして
//メソッドだけこっちでやりたかったけど、
//たぶんview側で全部処理できるように組まないと、中途半端。
// GET: /ApplicationForAdmin/
public ActionResult Index()
{
ApplicationInfoModel sm = new ApplicationInfoModel();
//これは遷移で持ってくるやつ
sm.氏名 = "testuser";
sm.所属 = "営業部";
sm.役職 = "主査";
sm.ユーザID = "a";
//ここから普通
sm.状態 = "2";
sm.表示件数 = 10;
sm.Find();
sm.SortAll();
sm.GetPage();
Session["書類申請"] = sm;
return(View("ApplicationManage", sm));
}
/// <summary>
/// Create model from service model
/// </summary>
/// <param name="model"></param>
public ApplicationInfoApiModel(ApplicationInfoModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ApplicationId = model.ApplicationId;
ApplicationType = model.ApplicationType;
ApplicationUri = model.ApplicationUri;
ApplicationName = model.ApplicationName;
Locale = model.Locale;
Certificate = model.Certificate;
ProductUri = model.ProductUri;
SiteId = model.SiteId;
HostAddresses = model.HostAddresses;
SupervisorId = model.SupervisorId;
DiscoveryProfileUri = model.DiscoveryProfileUri;
DiscoveryUrls = model.DiscoveryUrls;
Capabilities = model.Capabilities;
}
public async Task DeleteAsync(Guid id)
{
ApplicationInfo applicationInfoFromDB = await _applicationInfoRepository.FirstOrDefaultAsync(m => m.ID == id);
if (applicationInfoFromDB == null)
{
throw new DeployException("应用程序不存在");
}
_deploySqliteEFUnitOfWork.RegisterDelete(applicationInfoFromDB);
ApplicationInfoModel applicationInfoModel = _applicationManage.Delete(id);
try
{
await _deploySqliteEFUnitOfWork.CommitAsync();
}
catch (Exception)
{
_applicationManage.Add(applicationInfoModel);
throw;
}
}
/// <inheritdoc/>
public async Task OnApplicationEnabledAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
var endpoints = await GetEndpointsAsync(application.ApplicationId, true);
foreach (var registration in endpoints)
{
// Enable if disabled
if (!(registration.IsDisabled ?? false))
{
continue;
}
try {
var endpoint = registration.ToServiceModel();
endpoint.NotSeenSince = null;
var update = endpoint.ToEndpointRegistration(_serializer, false);
await _iothub.PatchAsync(registration.Patch(update, _serializer));
await _broker.NotifyAllAsync(
l => l.OnEndpointEnabledAsync(context, endpoint));
}
catch (Exception ex) {
_logger.Error(ex, "Failed re-enabling endpoint {id}",
registration.Id);
continue;
}
// Activate if it was activated before
if (!(registration.Activated ?? false))
{
continue; // No need to re-activate on enable
}
try {
await ActivateAsync(registration, context);
}
catch (Exception ex) {
_logger.Error(ex,
"Failed activating re-enabled endpoint {id}", registration.Id);
}
}
}
/// <inheritdoc/>
public async Task OnApplicationDisabledAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
// Disable endpoints
var endpoints = await GetEndpointsAsync(application.ApplicationId, true);
foreach (var registration in endpoints)
{
if (registration.Activated ?? false)
{
try {
registration.Activated = false; // Prevent patching...
await DeactivateAsync(registration, context);
registration.Activated = true; // reset activated state
}
catch (Exception ex) {
_logger.Error(ex, "Failed deactivating disabled endpoint {id}",
registration.Id);
}
}
// Disable if enabled
if (!(registration.IsDisabled ?? false))
{
try {
var endpoint = registration.ToServiceModel();
endpoint.NotSeenSince = DateTime.UtcNow;
var update = endpoint.ToEndpointRegistration(_serializer, true);
await _iothub.PatchAsync(registration.Patch(update, _serializer));
await _broker.NotifyAllAsync(
l => l.OnEndpointDisabledAsync(context, endpoint));
}
catch (Exception ex) {
_logger.Error(ex, "Failed disabling endpoint {id}", registration.Id);
}
}
}
}
/// <summary>
/// Check application info
/// </summary>
/// <param name="application"></param>
/// <returns></returns>
private async Task CheckApplicationInfoAsync(ApplicationInfoModel application)
{
// Test application certificate
var certEncoded = application.Certificate;
if (certEncoded == null)
{
await SendApplicationAlertAsync(application,
"Application without certificate found.", "No Certificate");
}
else
{
using (var cert = new X509Certificate2(certEncoded)) {
if (cert.SubjectName.RawData.SequenceEqual(cert.IssuerName.RawData))
{
await SendApplicationAlertAsync(application,
"Application with self-signed certificate found.",
$"Certificate is self signed by {cert.SubjectName.Name}");
}
else if (cert.NotAfter < DateTime.UtcNow)
{
await SendApplicationAlertAsync(application,
"Application has expired certificate.",
$"Certificate expired {cert.NotAfter}");
}
else if (cert.NotBefore > DateTime.UtcNow)
{
await SendApplicationAlertAsync(application,
"Application has certificate that is not yet valid.",
$"Certificate is valid from {cert.NotBefore}");
}
else
{
_logger.Verbose("Application certificate is valid.");
}
}
}
}
/// <inheritdoc/>
public async Task OnApplicationDeletedAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
// Get all endpoint registrations and for each one, call delete, if failure,
// stop half way and throw and do not complete.
var endpoints = await GetEndpointsAsync(application.ApplicationId, true);
foreach (var registration in endpoints)
{
var endpoint = registration.ToServiceModel();
try {
registration.Activated = false; // Prevents patching since we delete below.
await DeactivateAsync(registration, context);
}
catch (Exception ex) {
_logger.Error(ex, "Failed deleting registered endpoint endpoint {id}",
registration.Id);
}
await _iothub.DeleteAsync(registration.DeviceId);
await _broker.NotifyAllAsync(l => l.OnEndpointDeletedAsync(context, endpoint));
}
}
/// <inheritdoc/>
public Task OnApplicationUpdatedAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
return(Task.CompletedTask);
}
/// <inheritdoc/>
public Task OnApplicationDeletedAsync(RegistryOperationContextModel context,
string applicationId, ApplicationInfoModel application)
{
return(DeleteAsync(applicationId));
}
/// <inheritdoc/>
public Task OnApplicationEnabledAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
return(AddAsync(application));
}
/// <inheritdoc/>
public Task OnApplicationUpdatedAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
// TODO handle patching
return(UpdateAsync(application));
}
/// <inheritdoc/>
public Task OnApplicationUpdatedAsync(RegistryOperationContextModel context,
ApplicationInfoModel application)
{
Console.WriteLine($"Updated {application.ApplicationId}");
return(Task.CompletedTask);
}
