public async Task <string> Get()
{
Console.WriteLine("[" + DateTime.Now + "] Reloading keys!");
await KeyService.LoadKeys();
return("Reloaded keys!");
}
static void RunApplication()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
using (var settingsService = CreateSettingsService())
using (var gameService = new GameService(settingsService))
{
CheckForApplicationUpdates(settingsService);
new CharacterStatFileWriterService(settingsService, gameService);
var keyService = new KeyService();
var autoSplitService = new AutoSplitService(settingsService, gameService, keyService);
var serverService = new ServerService(gameService, settingsService);
var httpClientService = new HttpClientService(gameService, settingsService);
var mainWindow = new MainWindow(
settingsService,
gameService,
autoSplitService,
keyService,
serverService,
httpClientService
);
Application.Run(mainWindow);
serverService.Stop();
}
}
private void AddAction(KeyModifier keyModifier, string keyName, string operationName, Action action)
{
var shortcut = KeyService.GetShortcut(GetTestKey(keyName), keyModifier);
var operation = new Operation(operationName, action);
KeyService.RegisterShortcut(shortcut, operation);
}
public async void InitializeEMoney()
{
keyService = new KeyService("1234");
try
{
if (!keyService.HasSetupKey())
{
var savekeyForm = new SaveKeyForm();
savekeyForm.ShowDialog();
}
}
catch (Exception)
{
MessageBox.Show("ไม่ค้นพบกุญแจ");
}
saveKey = keyService.GetKey();
if (saveKey == null)
{
Environment.Exit(1);
}
privateKey = saveKey.SecretKey;
publicKey = saveKey.PublicKeyWif;
publickeylabel.Text = this.publicKey;
timer = new System.Timers.Timer();
timer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
timer.Interval = 60000;
timer.Enabled = true;
LoadData();
}
public async Task SearchKeyWithValues()
{
using (KeyService _keyService = new KeyService())
{
string keyOne = "toy-phil1";
await _keyService.SetKey(keyOne, "phil test 1");
string keyTwo = "toy-phil2";
await _keyService.SetKey(keyTwo, "phil test 2");
var results = await _keyService.SearchKeysGetValues("*hil*");
Assert.Equal(2, results.Count);
// right value 1
Assert.Equal("phil test 1", results.SingleOrDefault(x => x.Key == "toy-phil1").Value);
// right value 2
Assert.Equal("phil test 2", results.SingleOrDefault(x => x.Key == "toy-phil2").Value);
await _keyService.RemoveKey(keyOne);
await _keyService.RemoveKey(keyTwo);
}
}
public SettingsWindow(
ISettingsService settingsService,
ServerService serverService,
KeyService keyService,
HttpClientService httpClientService
)
{
Logger.Info("Creating settings window.");
this.settingsService = settingsService;
this.serverService = serverService;
this.keyService = keyService;
this.httpClientService = httpClientService;
RegisterServiceEventHandlers();
InitializeComponent();
InitializeAutoSplitTable();
PopulateSettingsFileList(settingsService.SettingsFileCollection);
// Unregister event handlers when we are done.
Disposed += (sender, args) =>
{
Logger.Info("Disposing settings window.");
UnregisterServiceEventHandlers();
};
ReloadComponentsWithCurrentSettings(settingsService.CurrentSettings);
// Loading the settings will dirty mark pretty much everything, here
// we just verify that nothing has actually changed yet.
MarkClean();
}
public DesAlgorithm(string key)
{
this.keyService = new KeyService(key);
this.permutationService = new PermutationService();
this.pBoxService = new PBoxService();
this.GenerateKeys();
}
private bool RequestDemoKey()
{
DemoKeyRequest keyRequest = new DemoKeyRequest();
keyRequest.Name = Name.Text;
keyRequest.Company = Company.Text;
keyRequest.Email = Email.Text;
keyRequest.Phone = Phone.Text;
keyRequest.Host = Request.Url.Host;
keyRequest.Port = Request.Url.Port;
KeyReply keyReply = KeyService.RequestDemoKey(keyRequest);
if (keyReply.Success)
{
// request succeeded, save new license to file
string filePath = Server.MapPath("~/App_Data/CommerceBuilder.lic");
File.WriteAllText(filePath, keyReply.LicenseKey);
return(true);
}
else
{
HandleError(keyReply.Message);
return(false);
}
}
public FrmMain()
{
InitializeComponent();
var keyService = new KeyService();
keyService.OnKeyLockStateChanged += OnKeyLockStateChanged;
mNotifyIcon = new NotifyIcon();
UpdateIcon(keyService.NumLockPressed);
mNotifyIcon.ContextMenuStrip = contextMenuStrip1;
mNotifyIcon.Visible = true;
ShowInTaskbar = false;
WindowState = FormWindowState.Minimized;
// Trick to hide the application from the task list.
var invisibleParent = new Form
{
FormBorderStyle = FormBorderStyle.FixedToolWindow,
ShowInTaskbar = false
};
Owner = invisibleParent;
}
/// <summary>
/// Invalidates zero or one identity-based cache entry based on the identity of a specific object. Typically called when saving data where updates may invalidate cache contents.
/// </summary>
/// <param name="baseType"></param>
/// <param name="props"></param>
public void InvalidateIdentityEntry(Type baseType, IDictionary <string, object> props)
{
StringBuilder sb = new StringBuilder(128);
sb.Append(baseType.Name);
var key = (from a in KeyService.ResolveKeyDefinitionForType(baseType) select props[a]).ToArray();
if (!key.Any())
{
throw new CEFInvalidOperationException("No primary key for this object makes it impossible to cache.");
}
foreach (var k in key)
{
sb.Append(k);
}
foreach (var c in _index.GetAllByName(nameof(MFSEntry.ByIdentityComposite), sb.ToString()))
{
lock (c.ObjSync)
{
c.Active = false;
c.Properties = null;
}
}
}
static void Main(string[] args)
{
//Specify bitcoin network
Network network = Network.TestNet;
KeyService keyService = new KeyService(network);
//Generates a brand new bitcoin address and private keys.
MultiSigAddress address2 = keyService.GenerateNewAddress(2, 3);
//Returns existing bitcoin address using existing private keys.
MultiSigAddress address1 = keyService.GetExistingAddress();
//Create me some private keys for fun
List <BitcoinSecret> keys = keyService.CreatePrivateKeys(3);
///////////////////////////////////////////
//Ignore this stuff. Just testing out some ideas.
//_bitcoinSession = new BitcoinSession(_network);
//BitCoinTransactionService bcService = new BitCoinTransactionService(_bitCoinSession);
//bcService.GetTransactionInfo("1f5dd12cfc57647bc2fe12832582fda1e46eb6cb1ea1b6cce35d1817ac06c691");
Console.ReadLine();
}
public WellKnownController(IEntityStore entityStore, ServerConfig entityData, RelevantEntitiesService relevantEntities, KeyService keyService, DbConnection connection)
{
_entityStore = entityStore;
_entityData = entityData;
_relevantEntities = relevantEntities;
_keyService = keyService;
_connection = connection;
}
public RetrievingEntityStore(IEntityStore next, EntityFlattener entityFlattener, IServiceProvider serviceProvider, KeyService keyService, IHttpContextAccessor contextAccessor)
{
Bypass = next;
_entityFlattener = entityFlattener;
_serviceProvider = serviceProvider;
_keyService = keyService;
_context = contextAccessor?.HttpContext;
}
protected void Page_PreRender(object sender, System.EventArgs e)
{
CommerceBuilder.Licensing.License license = null;
license = KeyService.GetCurrentLicense();
LicenseType.Text = license.KeyType.ToString();
DomainList.DataSource = license.Domains.ToArray();
DomainList.DataBind();
if (license.SubscriptionDate != null)
{
if (license.SubscriptionDate < LocaleHelper.LocalNow)
{
SubscriptionDate.Text = "Ended on " + license.SubscriptionDate.Value.ToString("dd-MMM-yyyy");
}
else
{
SubscriptionDate.Text = "Ends on " + license.SubscriptionDate.Value.ToString("dd-MMM-yyyy");
}
}
else
{
SubscriptionDate.Text = "None";
}
if (license.Expiration != null)
{
trExpiration.Visible = true;
Expiration.Text = license.Expiration.Value.ToString("yyyy-MMM-dd");
}
// FOR NON-DEMO LICENSES, SHOW DEMO MODE PANEL
if (license.KeyType != LicenseKeyType.DEMO)
{
DemoModePanel.Visible = true;
if (ApplicationSettings.Instance.UseDemoMode)
{
DemoModeButton.Text = "Disable Demo Mode";
DemoModeEnabledText.Visible = true;
DemoModeDisabledText.Visible = false;
}
else
{
DemoModeButton.Text = "Enable Demo Mode";
DemoModeEnabledText.Visible = false;
DemoModeDisabledText.Visible = true;
}
}
else
{
//FOR DEMO LICENSES, HIDE DEMO MODE PANEL
DemoModePanel.Visible = false;
}
if (Session["StoreLicenseUpdated"] != null)
{
SavedMessage.Visible = true;
SavedMessage.Text = string.Format(SavedMessage.Text, LocaleHelper.LocalNow);
Session.Remove("StoreLicenseUpdated");
}
}
public DeliverToActivityPubTask(EventQueueItem item, IEntityStore entityStore, EntityFlattener entityFlattener, IServiceProvider serviceProvider, DeliveryService deliveryService, SignatureVerifier verifier, KeyService keyService) : base(item)
{
_entityStore = entityStore;
_entityFlattener = entityFlattener;
_serviceProvider = serviceProvider;
_deliveryService = deliveryService;
_verifier = verifier;
_keyService = keyService;
}
private void InitializeMoney()
{
keyService = new KeyService("1234");
saveKey = keyService.GetKey(); //Prepare KeyPair of Sender
api = new DigibyteAPI(new APIOptions {
BaseURL = Program.InsightAPI
});
LoadData();
}
public SalmonConverter(IEntityStore entityStore, EntityFlattener flattener, AtomEntryParser parser, AtomEntryGenerator generator, SalmonConverterFactory factory, KeyService keyService)
{
_entityStore = entityStore;
_flattener = flattener;
_factory = factory;
_entryParser = parser;
_entryGenerator = generator;
_keyService = keyService;
}
public ActionResult CreateKey(CreateKeyModel model)
{
if (ModelState.IsValid)
{
return(RedirectToAction("ViewKey",
new { id = KeyService.CreateKey(model.SelectedItemId, model.KeyLimit) }));
}
model.Items = UserService.FillUserDropDownList();
return(View(model));
}
public FrmMain()
{
InitializeComponent();
mKeyService = new KeyService();
mKeyService.OnKeyLockStateChanged += (sender, args) => UpdateState(args.IsCapsLock, args.IsNumLock);
mTrayIcon = new NotifyIcon();
UpdateState(mKeyService.CapsLockPressed, mKeyService.NumLockPressed);
mTrayIcon.Visible = true;
ShowInTaskbar = false;
}
private void InitializeMoney()
{
keyService = new KeyService("1234");
saveKey = keyService.GetKey(); //Prepare KeyPair of Sender
api = new DigibyteAPI(new APIOptions {
BaseURL = Program.InsightAPI
});
t = new Thread(new ThreadStart(SendDGB));
t.Start();
}
static void Main(string[] args)
{
var keyService = new KeyService();
Parallel.For(1, 100, i => {
var result = keyService.GetKeyResult(1);
System.Console.WriteLine($"p1:index:{i} result[ startid:{result.maxid} step:{result.setp} delta:{result.delta} ]");
});
Parallel.For(1, 200, i => {
var result = keyService.GetKeyResult(2);
System.Console.WriteLine($"p2:index:{i} result[ startid:{result.maxid} step:{result.setp} delta:{result.delta} ]");
});
}
public MainWindow()
{
InitializeComponent();
// Get data for grid 1
Data1.ItemsSource = Inherit.JsonReader.LoadData <Inherit.Person>();
// Setup specific to CodexMicroORM - defining a primary (surrogate) key
KeyService.RegisterKey <NoInherit.Person>(nameof(NoInherit.Person.ID));
// Get data for grid 2 (CodexMicroORM)
Data2.ItemsSource = NoInherit.JsonReader.LoadData <NoInherit.Person>().AsDynamicBindable();
}
public async Task SearchKeyPermutation_Five()
{
using (KeyService _keyService = new KeyService())
{
string key = "rock4";
await _keyService.SetKey(key, "toy test 4");
var results = await _keyService.SearchKeys("*oc*");
Assert.Single(results);
await _keyService.RemoveKey(key);
}
}
public KeyServiceTests()
{
_options = CreateTestOptions();
_timeKeeper = new TimeKeeper(_options);
_repositoryMock = new Mock <IKeyRepository>();
_serializerMock = new Mock <IKeySerializer>();
_service = new KeyService(
_options,
_repositoryMock.Object,
_serializerMock.Object,
_timeKeeper,
new Mock <ILogger <KeyService> >().Object);
}
public SandboxTests()
{
Globals.WrapperSupports = WrappingSupport.Notifications;
Globals.WrappingClassNamespace = null;
Globals.WrapperClassNamePattern = "{0}Wrapped";
CEF.AddGlobalService(DBService.Create(new MSSQLProcBasedProvider($@"Data Source={DB_SERVER};Database=CodexMicroORMTest;Integrated Security=SSPI;MultipleActiveResultSets=true", defaultSchema: "CEFTest")));
CEF.AddGlobalService(new AuditService());
KeyService.RegisterKey <Person>(nameof(Person.PersonID));
KeyService.RegisterKey <Phone>("PhoneID");
KeyService.RegisterRelationship <Person>(TypeChildRelationship.Create <Person>("ParentPersonID").MapsToChildProperty(nameof(Person.Kids)));
KeyService.RegisterRelationship <Person>(TypeChildRelationship.Create <Phone>().MapsToParentProperty(nameof(Phone.Owner)).MapsToChildProperty(nameof(Person.Phones)));
}
public async Task SearchKeyPermutation_Two()
{
using (KeyService _keyService = new KeyService())
{
string key = "bear1";
await _keyService.SetKey(key, "toy test 2");
var results = await _keyService.SearchKeys("bea*");
Assert.Single(results);
await _keyService.RemoveKey(key);
}
}
public async Task KeyExists()
{
using (KeyService _keyService = new KeyService())
{
string keyName = "testkey4";
await _keyService.SetKey(keyName, "test123");
Assert.True(await _keyService.KeyExists(keyName));
await _keyService.RemoveKey(keyName);
Assert.False(await _keyService.KeyExists(keyName));
}
}
public JsonResult Single(string name, string key)
{
if (!KeyService.VerifyKey(key))
{
return(Json("Invalid key", JsonRequestBehavior.AllowGet));
}
if (!KeyService.RequestLimit(key))
{
return(Json("Your request limit have been reached", JsonRequestBehavior.AllowGet));
}
KeyService.AddRequest(key);
RequestService.CreateRequest(key, name, HttpContext.Request.UserHostAddress);
return(Json(GetGender.GetSingleGender(name), JsonRequestBehavior.AllowGet));
}
public async Task TestCreateMethodAddsShortSha()
{
var mockUUid = GetUuidService("uuid");
var mockRepo = GetKeyRepository();
var keyService = new KeyService(mockRepo.Object, mockUUid.Object, GetMockMetrics().Object);
var key = new Key
{
Body = "something",
Sha = "some",
CreatedAt = DateTime.Now
};
var newKey = await keyService.CreateKey(key);
Assert.AreEqual(newKey.ShortSha, "short_sha");
}
static void Main(string[] args)
{
var fileService = new FileService();
var keyService = new KeyService();
if (args.Length > 0)
{
var console = new ConsoleManager(args[0], fileService, keyService);
console.Start();
}
else
{
var console = new ConsoleManager(fileService, keyService);
console.Start();
}
}
