public ProgressAsyncHelper(AsyncHelper.DoWork doWork, AsyncHelper.WorkDone workDone, System.Windows.Forms.Form owner, string progressCaption)
{
m_progressForm = new Feng.Windows.Forms.ProgressForm();
m_asyncHelper = AsyncHelper.Start(doWork, new Feng.Async.AsyncHelper.WorkDone(delegate(object result)
{
this.m_progressForm.Stop();
this.m_progressForm.Close();
workDone(result);
}));
m_progressForm.ProgressStopped += new EventHandler((sender, e) =>
{
m_asyncHelper.AbortWorker();
});
m_progressForm.Start(owner, progressCaption);
}
public static unsafe void PackNegTest()
{
var helper = new AsyncHelper();
IOCompletionCallback callback = MyCallback(helper);
NativeOverlapped* nativeOverlapped;
Overlapped ov = new Overlapped();
nativeOverlapped = ov.Pack(new IOCompletionCallback(callback), null);
try
{
Assert.True(nativeOverlapped != null);
Assert.Throws<InvalidOperationException>(() => ov.Pack(new IOCompletionCallback(callback), null));
}
finally
{
Overlapped.Free(nativeOverlapped);
}
}
public static unsafe void PackPosTest()
{
#pragma warning disable 618
Overlapped ov = new Overlapped();
var helper = new AsyncHelper();
IOCompletionCallback callback = MyCallback(helper);
NativeOverlapped* nativeOverlapped = ov.Pack(callback);
try
{
Assert.True(nativeOverlapped != null);
Assert.True(ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped));
Assert.True(helper.Wait());
}
finally
{
Overlapped.Free(nativeOverlapped);
}
#pragma warning restore 618
}
public void TestInitializeBase()
{
Async = new AsyncHelper();
}
public static void Create <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, TTenant tenant)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
AsyncHelper.RunSync(() => tenantManager.CreateAsync(tenant));
}
public static void SetFeatureValues <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, int tenantId, params NameValue[] values)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
AsyncHelper.RunSync(() => tenantManager.SetFeatureValuesAsync(tenantId, values));
}
public static string GetFeatureValueOrNull <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, int tenantId, string featureName)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
return(AsyncHelper.RunSync(() => tenantManager.GetFeatureValueOrNullAsync(tenantId, featureName)));
}
public static TTenant GetById <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, int id)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
return(AsyncHelper.RunSync(() => tenantManager.GetByIdAsync(id)));
}
public User GetUserOrNull(UserIdentifier userIdentifier)
{
return(AsyncHelper.RunSync(() => GetUserOrNullAsync(userIdentifier)));
}
public ImportCertificateDialog(IServiceProvider serviceProvider, CertificatesFeature feature)
: base(serviceProvider)
{
InitializeComponent();
cbStore.SelectedIndex = 0;
if (Environment.OSVersion.Version < Version.Parse("6.2"))
{
// IMPORTANT: WebHosting store is available since Windows 8.
cbStore.Enabled = false;
}
if (!Helper.IsRunningOnMono())
{
JexusManager.NativeMethods.TryAddShieldToButton(btnOK);
}
var container = new CompositeDisposable();
FormClosed += (sender, args) => container.Dispose();
container.Add(
Observable.FromEventPattern <EventArgs>(btnBrowse, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
DialogHelper.ShowOpenFileDialog(txtFile, ".pfx|*.pfx|*.*|*.*");
}));
container.Add(
Observable.FromEventPattern <EventArgs>(txtFile, "TextChanged")
.Sample(TimeSpan.FromSeconds(1))
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
btnOK.Enabled = !string.IsNullOrWhiteSpace(txtFile.Text);
}));
container.Add(
Observable.FromEventPattern <EventArgs>(btnOK, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
try
{
// Load your certificate from file
Item = new X509Certificate2(txtFile.Text, txtPassword.Text, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);
Store = cbStore.SelectedIndex == 0 ? "Personal" : "WebHosting";
var service = (IConfigurationService)GetService(typeof(IConfigurationService));
if (service.ServerManager.Mode == WorkingMode.Jexus)
{
var server = (JexusServerManager)service.Server;
// Public Key;
StringBuilder publicBuilder = new StringBuilder();
publicBuilder.AppendLine("-----BEGIN CERTIFICATE-----");
publicBuilder.AppendLine(Convert.ToBase64String(Item.Export(X509ContentType.Cert), Base64FormattingOptions.InsertLineBreaks));
publicBuilder.AppendLine("-----END CERTIFICATE-----");
var file = AsyncHelper.RunSync(() => server.SaveCertificateAsync(publicBuilder.ToString()));
server.SetCertificate(file);
// Private Key
RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)Item.PrivateKey;
MemoryStream memoryStream = new MemoryStream();
TextWriter streamWriter = new StreamWriter(memoryStream);
PemWriter pemWriter = new PemWriter(streamWriter);
AsymmetricCipherKeyPair keyPair = DotNetUtilities.GetRsaKeyPair(rsa);
pemWriter.WriteObject(keyPair.Private);
streamWriter.Flush();
string output = Encoding.ASCII.GetString(memoryStream.GetBuffer()).Trim();
int indexOfFooter = output.IndexOf("-----END RSA PRIVATE KEY-----", StringComparison.Ordinal);
memoryStream.Close();
streamWriter.Close();
string key = output.Substring(0, indexOfFooter + 29);
var keyFile = AsyncHelper.RunSync(() => server.SaveKeyAsync(key));
server.SetKeyFile(keyFile);
service.ServerManager.CommitChanges();
}
else
{
try
{
using (var process = new Process())
{
// add certificate
var start = process.StartInfo;
start.Verb = "runas";
start.FileName = "cmd";
start.Arguments = string.Format(
"/c \"\"{4}\" /f:\"{0}\" /p:{1} /n:\"{2}\" /s:{3}\"",
txtFile.Text,
txtPassword.Text,
Item.FriendlyName,
cbStore.SelectedIndex == 0 ? "MY" : "WebHosting",
Path.Combine(Environment.CurrentDirectory, "certificateinstaller.exe"));
start.CreateNoWindow = true;
start.WindowStyle = ProcessWindowStyle.Hidden;
process.Start();
process.WaitForExit();
if (process.ExitCode == 0)
{
DialogResult = DialogResult.OK;
}
else
{
MessageBox.Show(process.ExitCode.ToString());
}
}
}
catch (Win32Exception ex)
{
// elevation is cancelled.
if (ex.NativeErrorCode != NativeMethods.ErrorCancelled)
{
Rollbar.Report(ex, ErrorLevel.Error, new Dictionary <string, object> {
{ "native", ex.NativeErrorCode }
});
// throw;
}
}
catch (Exception ex)
{
Rollbar.Report(ex, ErrorLevel.Error);
}
}
}
catch (Exception ex)
{
ShowError(ex, string.Empty, false);
}
}));
container.Add(
Observable.FromEventPattern <CancelEventArgs>(this, "HelpButtonClicked")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(EnvironmentVariableTarget =>
{
feature.ShowHelp();
}));
}
public static void SetFeatureValue <TTenant, TUser>(this TenantManager <TTenant, TUser> tenantManager, TTenant tenant, string featureName, string value)
where TTenant : CommonFrameTenant <TUser>
where TUser : CommonFrameUser <TUser>
{
AsyncHelper.RunSync(() => tenantManager.SetFeatureValueAsync(tenant, featureName, value));
}
public static TTenant FindByTenancyName <TTenant, TUser>(this TenantManager <TTenant, TUser> tenantManager, string tenancyName)
where TTenant : CommonFrameTenant <TUser>
where TUser : CommonFrameUser <TUser>
{
return(AsyncHelper.RunSync(() => tenantManager.FindByTenancyNameAsync(tenancyName)));
}
public static TTenant GetById <TTenant, TUser>(this TenantManager <TTenant, TUser> tenantManager, int id)
where TTenant : CommonFrameTenant <TUser>
where TUser : CommonFrameUser <TUser>
{
return(AsyncHelper.RunSync(() => tenantManager.GetByIdAsync(id)));
}
public override IMessageBus GetBusInstance()
{
IBusControl busControl = null;
var host = Options.Host.Split(':');
var options = new MqttClientOptionsBuilder()
.WithClientId(Guid.NewGuid().ToString())
.WithTcpServer(host[0], int.Parse(host[1]))
.Build();
var factory = new MqttFactory();
var mqttClient = factory.CreateMqttClient();
mqttClient.UseApplicationMessageReceivedHandler(async e =>
{
await busControl.Publish(new MqttMessageReceivedEvent
{
Topic = e.ApplicationMessage.Topic,
Payload = e.ApplicationMessage.Payload,
});
});
mqttClient.UseConnectedHandler(async e =>
{
//Topic格式
//RootTopic/{SourceClientId}/{TargetClientId}/{SourceEndpoint}/{TargetEndpoint}/{MessageBodyType}/{MessageType}/{MessageId}
string topic;
foreach (var aMessageType in Cache.MessageTypes)
{
//事件广播
topic = $"{Topic.RootTopic}/+/+/+/+/{aMessageType.FullName}/{MessageTypes.Event}/+";
await mqttClient.SubscribeAsync(topic);
Logger.LogInformation("MessageBus:Subscribe To Topic {Topic}", topic);
//命令单播
topic = $"{Topic.RootTopic}/+/+/+/{Options.Endpoint}/{aMessageType.FullName}/{MessageTypes.Command}/+";
await mqttClient.SubscribeAsync(topic);
Logger.LogInformation("MessageBus:Subscribe To Topic {Topic}", topic);
Logger.LogInformation("MessageBus:Subscribe {MessageType}", aMessageType);
}
//请求返回
topic = $"{Topic.RootTopic}/+/{options.ClientId}/+/+/+/{MessageTypes.Response}/+";
await mqttClient.SubscribeAsync(topic);
Logger.LogInformation("MessageBus:Subscribe To Topic {Topic}", topic);
});
mqttClient.UseDisconnectedHandler(async e =>
{
Logger.LogWarning("MessageBus:Disconnected from {Host}", Options.Host);
await Task.Delay(TimeSpan.FromSeconds(3));
try
{
await mqttClient.ConnectAsync(options, CancellationToken.None);
}
catch (Exception ex)
{
Logger.LogError(ex, "MessageBus:Reconnect To {Host} Fail", Options.Host);
}
});
busControl = Bus.Factory.CreateUsingInMemory(sbc =>
{
sbc.ReceiveEndpoint(ep =>
{
ep.Handler <MqttMessageReceivedEvent>(async context =>
{
await new MqttMessageReceivedEventHandler(ServiceProvider, Options, mqttClient)
.Handle(context.Message);
});
});
});
busControl.Start();
AsyncHelper.RunSync(() => mqttClient.ConnectAsync(options));
Logger.LogInformation("MessageBus:Started (Host:{Host})", Options.Host);
return(new MqttMessageBus(Options, mqttClient));
}
/// <inheritdoc/>
public SettingManager(ISettingDefinitionManager settingDefinitionManager)
{
_settingDefinitionManager = settingDefinitionManager;
AbpSession = NullAbpSession.Instance;
SettingStore = DefaultConfigSettingStore.Instance;
_applicationSettings = new Lazy <Dictionary <string, SettingInfo> >(() => AsyncHelper.RunSync(GetApplicationSettingsFromDatabase), true); //TODO: Run async
_tenantSettingCache = new AsyncThreadSafeObjectCache <Dictionary <string, SettingInfo> >(new MemoryCache(GetType().FullName + ".TenantSettings"), TimeSpan.FromMinutes(60)); //TODO: Get constant from somewhere else.
_userSettingCache = new AsyncThreadSafeObjectCache <Dictionary <string, SettingInfo> >(new MemoryCache(GetType().FullName + ".UserSettings"), TimeSpan.FromMinutes(20)); //TODO: Get constant from somewhere else.
}
public void MatchingSkillsTest(bool skillsAreSelected, int?expectedMatchingCount, bool shouldShowMatchingCount)
{
//Set up
var searchServiceFake = A.Fake <ISearchQueryService <JobProfileIndex> >(ops => ops.Strict());
var loggerFake = A.Fake <IApplicationLogger>();
var asyncHelper = new AsyncHelper();
var webAppContextFake = A.Fake <IWebAppContext>(ops => ops.Strict());
var defaultJobProfilePage = "/jobprofile-details/";
var stateManagerFake = A.Fake <IPreSearchFilterStateManager>(ops => ops.Strict());
var mapperCfg = new MapperConfiguration(cfg =>
{
cfg.AddProfile <JobProfilesAutoMapperProfile>();
});
var buildSearchFilterServiceFake = A.Fake <IBuildSearchFilterService>(ops => ops.Strict());
var expectedSearchResultsViewModel = Enumerable.Empty <JobProfileSearchResultItemViewModel>();
var dummySearchResult = A.Dummy <SearchResult <JobProfileIndex> >();
dummySearchResult.Count = 1;
var dummyReturnedResults = new List <SearchResultItem <JobProfileIndex> >()
{
new SearchResultItem <JobProfileIndex>
{
ResultItem = new JobProfileIndex()
{
Skills = new List <string>()
{
"Skill1", "Skill2", "Skill3"
},
UrlName = "dummy-url",
}
}
};
dummySearchResult.Results = dummyReturnedResults;
var testPreSearchFilterState = new PreSearchFilterState();
if (skillsAreSelected)
{
testPreSearchFilterState.Sections = new List <PreSearchFilterSection>()
{
new PreSearchFilterSection()
{
SectionDataType = PreSearchFilterType.Skill,
Options = new List <PreSearchFilterOption>()
{
new PreSearchFilterOption()
{
OptionKey = "Skill2", IsSelected = true
}
}
}
};
}
A.CallTo(() => searchServiceFake.SearchAsync(A <string> ._, A <SearchProperties> ._)).Returns(dummySearchResult);
A.CallTo(() => buildSearchFilterServiceFake.GetSearchTerm(A <SearchProperties> ._, A <PreSearchFiltersResultsModel> ._, A <string[]> ._)).Returns("*");
A.CallTo(() => buildSearchFilterServiceFake.BuildPreSearchFilters(A <PreSearchFiltersResultsModel> ._, A <Dictionary <string, PreSearchFilterLogicalOperator> > ._)).Returns(nameof(SearchProperties.FilterBy));
A.CallTo(() => stateManagerFake.GetPreSearchFilterState()).Returns(testPreSearchFilterState);
A.CallTo(() => stateManagerFake.GetStateJson()).Returns(string.Empty);
A.CallTo(() => stateManagerFake.RestoreState(A <string> ._)).DoesNothing();
A.CallTo(() => stateManagerFake.UpdateSectionState(A <PreSearchFilterSection> ._)).DoesNothing();
//Instantiate & Act
var psfSearchController = new PsfSearchController(searchServiceFake, webAppContextFake, mapperCfg.CreateMapper(), asyncHelper, buildSearchFilterServiceFake, stateManagerFake, loggerFake)
{
JobProfileDetailsPage = defaultJobProfilePage,
ShowMacthingSkillCount = shouldShowMatchingCount
};
var searchMethodCall = psfSearchController.WithCallTo(c => c.Index(new PsfModel {
Section = new PsfSection {
Options = new List <PsfOption>()
}
}, new PsfSearchResultsViewModel(), 1));
//Assert
searchMethodCall
.ShouldRenderView("SearchResult")
.WithModel <PsfSearchResultsViewModel>(vm =>
{
vm.SearchResults.FirstOrDefault().MatchingSkillsCount.Should().Be(expectedMatchingCount);
})
.AndNoModelErrors();
}
public void IndexSearchPagingTest(int resultCount)
{
var searchServiceFake = A.Fake <ISearchQueryService <JobProfileIndex> >(ops => ops.Strict());
var loggerFake = A.Fake <IApplicationLogger>();
var asyncHelper = new AsyncHelper();
var webAppContextFake = A.Fake <IWebAppContext>(ops => ops.Strict());
var defaultJobProfilePage = "/jobprofile-details/";
var stateManagerFake = A.Fake <IPreSearchFilterStateManager>(ops => ops.Strict());
var mapperCfg = new MapperConfiguration(cfg =>
{
cfg.AddProfile <JobProfilesAutoMapperProfile>();
});
var buildSearchFilterServiceFake = A.Fake <IBuildSearchFilterService>(ops => ops.Strict());
// Set up calls
var expectedSearchResultsViewModel = Enumerable.Empty <JobProfileSearchResultItemViewModel>();
var dummySearchResult = A.Dummy <SearchResult <JobProfileIndex> >();
var expectedTotalMessage = resultCount == 1 ? "1 result found" : $"{resultCount} results found";
var dummyIndex = new JobProfileIndex
{
Title = nameof(JobProfileIndex.Title),
AlternativeTitle = new[] { "alt" },
SalaryStarter = 10,
SalaryExperienced = 10,
Overview = "overview",
UrlName = "dummy-url",
JobProfileCategoriesWithUrl = new[] { "CatOneURL|Cat One", "CatTwoURL|Cat Two" }
};
dummySearchResult.Count = resultCount;
var endList = new List <SearchResultItem <JobProfileIndex> >(resultCount);
for (var i = 0; i < resultCount; i++)
{
endList.Add(new SearchResultItem <JobProfileIndex>
{
ResultItem = dummyIndex
});
}
dummySearchResult.Results = endList;
var expectedVmList = new List <JobProfileSearchResultItemViewModel>();
foreach (var dummyResult in dummySearchResult.Results)
{
expectedVmList.Add(
new JobProfileSearchResultItemViewModel
{
ResultItemTitle = dummyResult.ResultItem.Title,
ResultItemAlternativeTitle = string.Join(", ", dummyResult.ResultItem.AlternativeTitle).Trim().TrimEnd(','),
ResultItemSalaryRange = string.Format(new CultureInfo("en-GB", false), "{0:C0} to {1:C0}", dummyResult.ResultItem.SalaryStarter, dummyResult.ResultItem.SalaryExperienced),
ResultItemOverview = dummyResult.ResultItem.Overview,
ResultItemUrlName = $"{defaultJobProfilePage}{dummyResult.ResultItem.UrlName}",
Rank = (int)dummyResult.Rank,
Score = dummyResult.Score,
JobProfileCategoriesWithUrl = dummyResult.ResultItem.JobProfileCategoriesWithUrl
});
}
expectedSearchResultsViewModel = expectedVmList.AsEnumerable();
A.CallTo(() => searchServiceFake.SearchAsync(A <string> ._, A <SearchProperties> ._)).Returns(dummySearchResult);
A.CallTo(() => buildSearchFilterServiceFake.GetSearchTerm(A <SearchProperties> ._, A <PreSearchFiltersResultsModel> ._, A <string[]> ._))
.Returns("*");
A.CallTo(() => buildSearchFilterServiceFake.BuildPreSearchFilters(A <PreSearchFiltersResultsModel> ._, A <Dictionary <string, PreSearchFilterLogicalOperator> > ._))
.Returns(nameof(SearchProperties.FilterBy));
A.CallTo(() => stateManagerFake.GetPreSearchFilterState()).Returns(new PreSearchFilterState());
A.CallTo(() => stateManagerFake.GetStateJson()).Returns(string.Empty);
A.CallTo(() => stateManagerFake.RestoreState(A <string> ._)).DoesNothing();
A.CallTo(() => stateManagerFake.UpdateSectionState(A <PreSearchFilterSection> ._)).DoesNothing();
//Instantiate & Act
var psfSearchController = new PsfSearchController(searchServiceFake, webAppContextFake, mapperCfg.CreateMapper(), asyncHelper, buildSearchFilterServiceFake, stateManagerFake, loggerFake)
{
JobProfileDetailsPage = defaultJobProfilePage
};
var searchMethodCall = psfSearchController.WithCallTo(c => c.Index(new PsfModel {
Section = new PsfSection {
Options = new List <PsfOption>()
}
}, new PsfSearchResultsViewModel(), 1));
//Assert
searchMethodCall
.ShouldRenderView("SearchResult")
.WithModel <PsfSearchResultsViewModel>(vm =>
{
vm.MainPageTitle.Should().Be(psfSearchController.MainPageTitle);
vm.SecondaryText.Should().BeEquivalentTo(psfSearchController.SecondaryText);
vm.TotalResultsMessage.Should().Be(expectedTotalMessage);
vm.TotalResultCount.Should().Be(resultCount);
vm.SearchResults.Should().NotBeNull();
vm.SearchResults.Should().BeEquivalentTo(expectedSearchResultsViewModel);
vm.BackPageUrl.OriginalString.Should().BeEquivalentTo(psfSearchController.BackPageUrl);
vm.BackPageUrlText.Should().BeEquivalentTo(psfSearchController.BackPageUrlText);
})
.AndNoModelErrors();
A.CallTo(() => searchServiceFake.SearchAsync(A <string> ._, A <SearchProperties> ._)).MustHaveHappened();
A.CallTo(() => buildSearchFilterServiceFake.BuildPreSearchFilters(A <PreSearchFiltersResultsModel> ._, A <Dictionary <string, PreSearchFilterLogicalOperator> > ._))
.MustHaveHappened();
A.CallTo(() => stateManagerFake.RestoreState(A <string> ._)).MustHaveHappened();
A.CallTo(() => stateManagerFake.GetPreSearchFilterState()).MustHaveHappened();
A.CallTo(() => stateManagerFake.GetStateJson()).MustHaveHappened();
}
internal static unsafe IOCompletionCallback MyCallback(AsyncHelper helper)
{
IOCompletionCallback del = delegate (uint param1, uint param2, NativeOverlapped* overlapped)
{
Overlapped ov = new Overlapped();
NativeOverlapped* nativeOverlapped2 = ov.Pack(helper.Callback, null);
ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped2);
};
return del;
}
public void Send(NoticeMessageInput input)
{
AsyncHelper.RunSync(() => SendAsync(input));
}
public static void ResetAllFeatures <TTenant, TUser>(this TenantManager <TTenant, TUser> tenantManager, int tenantId)
where TTenant : CommonFrameTenant <TUser>
where TUser : CommonFrameUser <TUser>
{
AsyncHelper.RunSync(() => tenantManager.ResetAllFeaturesAsync(tenantId));
}
private void actConnectServer_Execute(object sender, EventArgs e)
{
var names = new List <string>();
names.Add("Start Page");
foreach (var item in treeView1.Nodes)
{
var serverNode = item as ServerTreeNode;
if (serverNode != null)
{
names.Add(serverNode.DisplayName);
}
}
var dialog = new ConnectionWizard(_serviceContainer, names.ToArray());
if (dialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
var data = (ConnectionWizardData)dialog.WizardData;
ServerTreeNode node;
if (data.Mode == WorkingMode.Jexus)
{
node = ServerTreeNode.CreateJexusNode(
_serviceContainer,
data.Name,
data.HostName,
data.UserName + "|" + data.Password,
data.CertificateHash,
data.Server,
isLocalhost: true);
node.SetHandler();
var path = Path.GetTempFileName();
var random = Guid.NewGuid().ToString();
File.WriteAllText(path, random);
node.IsLocalhost = AsyncHelper.RunSync(() => ((JexusServerManager)node.ServerManager).LocalhostTestAsync(path, random));
data.Server.IsLocalhost = node.IsLocalhost;
}
else
{
node = ServerTreeNode.CreateIisExpressNode(
_serviceContainer,
data.Name,
data.FileName,
data.Server,
ignoreInCache: false);
}
try
{
RegisterServer(node);
// TODO: trigger the load in connection wizard to throw exception earlier.
node.LoadServer(cmsApplicationPools, cmsSites, cmsSite);
actSave.Enabled = true;
}
catch (Exception ex)
{
File.WriteAllText(DialogHelper.DebugLog, ex.ToString());
var last = ex;
while (last is AggregateException)
{
last = last.InnerException;
}
var message = new StringBuilder();
message.AppendLine("Could not connect to the specified computer.")
.AppendLine()
.AppendFormat("Details: {0}", last?.Message);
MessageBox.Show(message.ToString(), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static IdentityResult Create <TTenant, TUser>(this TenantManager <TTenant, TUser> tenantManager, TTenant tenant)
where TTenant : CommonFrameTenant <TUser>
where TUser : CommonFrameUser <TUser>
{
return(AsyncHelper.RunSync(() => tenantManager.CreateAsync(tenant)));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
await AsyncHelper.DoAsync(Start, cancellationToken);
}
/// <summary>
/// Authorizes current user for given permission or permissions,
/// throws <see cref="AbpAuthorizationException"/> if not authorized.
/// User it authorized if any of the <see cref="permissionNames"/> are granted.
/// </summary>
/// <param name="permissionChecker">Permission checker</param>
/// <param name="requireAll">
/// If this is set to true, all of the <see cref="permissionNames"/> must be granted.
/// If it's false, at least one of the <see cref="permissionNames"/> must be granted.
/// </param>
/// <param name="permissionNames">Name of the permissions to authorize</param>
/// <exception cref="AbpAuthorizationException">Throws authorization exception if</exception>
public static void Authorize(this IPermissionChecker permissionChecker, bool requireAll, params string[] permissionNames)
{
AsyncHelper.RunSync(() => AuthorizeAsync(permissionChecker, requireAll, permissionNames));
}
public static TTenant FindByTenancyName <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, string tenancyName)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
return(AsyncHelper.RunSync(() => tenantManager.FindByTenancyNameAsync(tenancyName)));
}
/// <summary>
/// Checks if a user is granted for a permission.
/// </summary>
/// <param name="permissionChecker">Permission checker</param>
/// <param name="user">User to check</param>
/// <param name="permissionName">Name of the permission</param>
public static bool IsGranted(this IPermissionChecker permissionChecker, UserIdentifier user, string permissionName)
{
return(AsyncHelper.RunSync(() => permissionChecker.IsGrantedAsync(user, permissionName)));
}
public static IReadOnlyList <NameValue> GetFeatureValues <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, int tenantId)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
return(AsyncHelper.RunSync(() => tenantManager.GetFeatureValuesAsync(tenantId)));
}
/// <summary>
/// Checks if current user is granted for given permission.
/// </summary>
/// <param name="permissionChecker">Permission checker</param>
/// <param name="requiresAll">True, to require all given permissions are granted. False, to require one or more.</param>
/// <param name="permissionNames">Name of the permissions</param>
public static bool IsGranted(this IPermissionChecker permissionChecker, bool requiresAll, params string[] permissionNames)
{
return(AsyncHelper.RunSync(() => IsGrantedAsync(permissionChecker, requiresAll, permissionNames)));
}
public static void SetFeatureValue <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, TTenant tenant, string featureName, string value)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
AsyncHelper.RunSync(() => tenantManager.SetFeatureValueAsync(tenant, featureName, value));
}
public override byte[] SendMsg(byte[] message)
{
return(AsyncHelper.RunSync(() => SendMsgAsync(message)));
}
public static void ResetAllFeatures <TTenant, TUser>(this AbpTenantManager <TTenant, TUser> tenantManager, int tenantId)
where TTenant : AbpTenant <TUser>
where TUser : AbpUserBase
{
AsyncHelper.RunSync(() => tenantManager.ResetAllFeaturesAsync(tenantId));
}
protected virtual void OverrideOptions(IdentityOptions options)
{
AsyncHelper.RunSync(() => OverrideOptionsAsync(options));
}
public static unsafe void UnPackTest()
{
Assert.Throws<ArgumentNullException>(() => Overlapped.Unpack(null));
Overlapped ov = new Overlapped();
var helper = new AsyncHelper();
IOCompletionCallback callback = MyCallback(helper);
NativeOverlapped* nativeOverlapped = ov.Pack(new IOCompletionCallback(callback), null);
try
{
Assert.True(null != nativeOverlapped);
Overlapped ov1 = Overlapped.Unpack(nativeOverlapped);
Assert.Same(ov1, ov);
}
finally
{
Overlapped.Free(nativeOverlapped);
}
}
/// <summary>
///
/// </summary>
/// <param name="doWork"></param>
/// <param name="workDone"></param>
public static AsyncHelper Start(AsyncHelper.DoWork doWork, AsyncHelper.WorkDone workDone, System.Windows.Forms.Form owner, string progressCaption)
{
var i = new ProgressAsyncHelper(doWork, workDone, owner, progressCaption);
return i.m_asyncHelper;
}
protected virtual User GetCurrentUser()
{
return(AsyncHelper.RunSync(GetCurrentUserAsync));
}
private async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// Get a deferral because we use an awaitable API below to respond to the message
// and we don't want this call to get cancelled while we are waiting.
var messageDeferral = args.GetDeferral();
var message = args.Request.Message;
var returnData = new ValueSet();
string command = message["q"] as string;
switch (command)
{
case "lyric":
var title = message["title"] as string;
message.TryGetValue("artist", out object art);
var artists = art as string;
message.TryGetValue("album", out object alb);
var lyalbum = alb as string;
var localLrc = await LyricSearcher.SearchLrcLocalAsync(title, artists, lyalbum);
if (!localLrc.IsNullorEmpty())
{
returnData.Add("result", localLrc);
returnData.Add("status", 1);
break;
}
if (message.ContainsKey("ID") && message.ContainsKey("service") && message["service"] as string == "Aurora.Music.Services")
{
var result = await LyricSearcher.GetSongLrcByID(message["ID"] as string);
if (!result.IsNullorEmpty())
{
await LyricSearcher.SaveLrcLocalAsync(title, artists, lyalbum, result);
returnData.Add("result", result);
returnData.Add("status", 1);
break;
}
}
var substitutes = await LyricSearcher.GetSongLrcListAsync(title, artists);
if (!substitutes.IsNullorEmpty())
{
var result = await ApiRequestHelper.HttpGet(substitutes.First().Value);
if (!result.IsNullorEmpty())
{
result = HttpUtility.HtmlDecode(result);
await LyricSearcher.SaveLrcLocalAsync(title, artists, lyalbum, result);
returnData.Add("result", result);
returnData.Add("status", 1);
}
else
{
returnData.Add("result", null);
returnData.Add("status", 0);
}
}
else
{
returnData.Add("result", null);
returnData.Add("status", 0);
}
break;
case "online_music":
var action = message["action"] as string;
switch (action)
{
case "search":
var result = await OnlineMusicSearcher.SearchAsync(message["keyword"] as string);
var resultList = new List <PropertySet>();
if (result == null && result.Data != null)
{
returnData.Add("status", 0);
break;
}
foreach (var item in result.Data.Song.ListItems)
{
var set = new PropertySet
{
["title"] = item.Title,
["description"] = item.SingerItems[0]?.Title,
["addtional"] = item.Album.Title,
["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(item.Album.Mid),
["type"] = "song",
["id"] = new string[] { item.Mid },
["album_id"] = item.Album.Mid
};
resultList.Add(set);
}
if (!resultList.IsNullorEmpty())
{
returnData.Add("search_result", JsonConvert.SerializeObject(resultList.ToArray()));
returnData.Add("status", 1);
}
break;
case "song":
var song = await OnlineMusicSearcher.GetSongAsync(message["id"] as string);
if (song != null && !song.DataItems.IsNullorEmpty())
{
DateTime.TryParseExact(song.DataItems[0].Album.Time_Public, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var t);
// TODO: property
var songRes = new PropertySet
{
["title"] = song.DataItems[0].Title,
["id"] = song.DataItems[0].Mid,
["album"] = song.DataItems[0].Album.Name,
["album_id"] = song.DataItems[0].Album.Mid,
["performers"] = song.DataItems[0].SingerItems.Select(x => x.Name).ToArray(),
["year"] = t.Year,
["bit_rate"] = Settings.Current.GetPreferredBitRate() * 1000,
["track"] = song.DataItems[0].Index_Album,
["track_count"] = 0,
["duration"] = TimeSpan.Zero.ToString()
};
songRes["album_artists"] = songRes["performers"];
var picture = OnlineMusicSearcher.GeneratePicturePathByID(song.DataItems[0].Album.Mid);
songRes["picture_path"] = picture;
songRes["file_url"] = await OnlineMusicSearcher.GenerateFileUriByID(message["id"] as string, Settings.Current.GetPreferredBitRate());
songRes["file_type"] = OnlineMusicSearcher.GenerateFileTypeByID(message["id"] as string, Settings.Current.GetPreferredBitRate());
returnData.Add("song_result", JsonConvert.SerializeObject(songRes));
returnData.Add("status", 1);
}
break;
case "album":
var album = await OnlineMusicSearcher.GetAlbumAsync(message["id"] as string);
if (album != null && album.Data != null)
{
DateTime.TryParseExact(album.Data.GetAlbumInfo.Fpublic_Time, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var t);
var albumRes = new PropertySet
{
["name"] = album.Data.GetAlbumInfo.Falbum_Name,
["desription"] = album.Data.GetAlbumDesc.Falbum_Desc.Replace("\n", "\r\n\r\n"),
["year"] = t.Year,
["track_count"] = album.Data.GetSongInfoItems.Count,
["disc_count"] = album.Data.GetSongInfoItems.Max(x => x.Index_Cd) + 1,
["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(message["id"] as string),
["genres"] = new string[] { album.Data.Genre }
};
returnData.Add("album_result", JsonConvert.SerializeObject(albumRes));
returnData.Add("songs", JsonConvert.SerializeObject(album.Data.GetSongInfoItems.Select(x =>
{
var p = new PropertySet()
{
["id"] = x.Mid,
["title"] = x.Name,
["album"] = x.Album.Name,
["album_id"] = x.Album.Mid,
["performers"] = x.SingerItems.Select(y => y.Name).ToArray(),
["year"] = t.Year,
["bit_rate"] = Settings.Current.GetPreferredBitRate() * 1000,
["picture_path"] = OnlineMusicSearcher.GeneratePicturePathByID(x.Album.Mid),
["track"] = x.Index_Album,
["duration"] = TimeSpan.Zero.ToString(),
["file_url"] = AsyncHelper.RunSync(async() => await OnlineMusicSearcher.GenerateFileUriByID(x.Mid, Settings.Current.GetPreferredBitRate())),
["file_type"] = OnlineMusicSearcher.GenerateFileTypeByID(x.Mid, Settings.Current.GetPreferredBitRate())
};
p["album_artists"] = p["performers"];
return(p);
})));
returnData.Add("album_artists", JsonConvert.SerializeObject(album.Data.SingerInfoItems.Select(x =>
{
return(new PropertySet()
{
["name"] = x.Fsinger_Name,
["id"] = x.Fsinger_Mid,
});
})));
returnData.Add("status", 1);
}
break;
case "artist":
var artist = await OnlineMusicSearcher.GetArtistAsync(message["id"] as string);
break;
default:
break;
}
break;
case "online_meta":
var meta_action = message["action"] as string;
switch (meta_action)
{
case "album":
var meta_album = await LastfmSearcher.GetAlbumInfo(message["album"] as string, message["artist"] as string);
if (meta_album != null)
{
returnData.Add("status", 1);
returnData.Add("album_result", JsonConvert.SerializeObject(new PropertySet()
{
["name"] = meta_album.Name,
["artwork"] = meta_album.AltArtwork?.OriginalString,
["desc"] = meta_album.Description,
["artist"] = meta_album.Artist,
["year"] = meta_album.Year
}));
}
break;
case "artist":
var meta_artist = await LastfmSearcher.GetArtistInfo(message["artist"] as string);
if (meta_artist != null)
{
returnData.Add("status", 1);
returnData.Add("artist_result", JsonConvert.SerializeObject(new PropertySet()
{
["name"] = meta_artist.Name,
["avatar"] = meta_artist.AvatarUri?.OriginalString,
["desc"] = meta_artist.Description,
}));
}
break;
}
break;
default:
returnData.Add("status", 0);
break;
}
await args.Request.SendResponseAsync(returnData);
// Return the data to the caller.
// Complete the deferral so that the platform knows that we're done responding to the app service call.
// Note for error handling: this must be called even if SendResponseAsync() throws an exception.
messageDeferral.Complete();
}
private string GetResponse(string uri, string query)
{
allDone.Reset();
HttpWebRequest request = HttpWebRequest.Create(uri) as HttpWebRequest;
request.Method = "POST";
AsyncHelper asyncHlp = new AsyncHelper() { Query = query, Request = request };
request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), asyncHlp);
allDone.WaitOne();
return asyncHlp.Result;
}
/// <summary>
/// Checks if permission dependency is satisfied.
/// </summary>
/// <param name="permissionDependency">The permission dependency</param>
/// <param name="context">Context.</param>
public static bool IsSatisfied(this IPermissionDependency permissionDependency, IPermissionDependencyContext context)
{
return(AsyncHelper.RunSync(() => permissionDependency.IsSatisfiedAsync(context)));
}
