public List <EventData> Get(string Project, long LastEventId)
{
return(SqlConnector.GetUserVotes(Project, LastEventId));
}
public RemovePlaylist(IUserPlaylistViewModel viewModel)
{
this._viewModel = viewModel;
this._listRepository = new PlaylistRepository(SqlConnector.GetDefaultConnection());
}
public void Post(long IssueId, [FromBody] IssueDiagnosticData Data)
{
SqlConnector.AddDiagnostic(IssueId, Data);
}
public void Put(long BuildId, [FromBody] IssueBuildUpdateData Data)
{
SqlConnector.UpdateBuild(BuildId, Data.Outcome);
}
public void Delete(long id)
{
SqlConnector.DeleteIssue(id);
}
public object Post(long IssueId, [FromBody] IssueBuildData Data)
{
long BuildId = SqlConnector.AddBuild(IssueId, Data);
return(new { Id = BuildId });
}
public static List <T> ToListWithInvalidation <T>(this IQueryable <T> simpleQuery, Type type, string exceptionContext, Action <SqlNotificationEventArgs> invalidation)
{
if (!WithSqlDependency)
{
throw new InvalidOperationException("ToListWithInvalidation requires SqlDependency");
}
ITranslateResult tr;
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
tr = ((DbQueryProvider)simpleQuery.Provider).GetRawTranslateResult(simpleQuery.Expression);
OnChangeEventHandler onChange = (object sender, SqlNotificationEventArgs args) =>
{
try
{
if (args.Type != SqlNotificationType.Change)
{
throw new InvalidOperationException(
"Problems with SqlDependency (Type : {0} Source : {1} Info : {2}) on query: \r\n{3}"
.FormatWith(args.Type, args.Source, args.Info, tr.MainCommand.PlainSql()));
}
if (args.Info == SqlNotificationInfo.PreviousFire)
{
throw new InvalidOperationException("The same transaction that loaded the data is invalidating it!")
{
Data = { { "query", tr.MainCommand.PlainSql() } }
}
}
;
if (CacheLogic.LogWriter != null)
{
CacheLogic.LogWriter.WriteLine("Change ToListWithInvalidations {0} {1}".FormatWith(typeof(T).TypeName()), exceptionContext);
}
invalidation(args);
}
catch (Exception e)
{
e.LogException(c => c.ControllerName = exceptionContext);
}
};
SimpleReader reader = null;
Expression <Func <IProjectionRow, T> > projectorExpression = (Expression <Func <IProjectionRow, T> >)tr.GetMainProjector();
Func <IProjectionRow, T> projector = projectorExpression.Compile();
List <T> list = new List <T>();
CacheLogic.AssertSqlDependencyStarted();
Table table = Schema.Current.Table(type);
DatabaseName db = table.Name.Schema?.Database;
SqlConnector subConnector = ((SqlConnector)Connector.Current).ForDatabase(db);
if (CacheLogic.LogWriter != null)
{
CacheLogic.LogWriter.WriteLine("Load ToListWithInvalidations {0} {1}".FormatWith(typeof(T).TypeName()), exceptionContext);
}
using (new EntityCache())
using (var r = EntityCache.NewRetriever()) {
subConnector.ExecuteDataReaderDependency(tr.MainCommand, onChange, StartSqlDependencyAndEnableBrocker, fr =>
{
if (reader == null)
{
reader = new SimpleReader(fr, r);
}
list.Add(projector(reader));
}, CommandType.Text);
r.CompleteAll();
}
return(list);
}
public void Put(long id, IssueUpdateData Issue)
{
SqlConnector.UpdateIssue(id, Issue);
}
public FlightModel GetLatest()
{
return(SqlConnector.GetLatestFlight());
}
public int GetLatestID()
{
return(SqlConnector.GetLatestFlightID());
}
public IEnumerable <FlightModel> FlightByMonth(int MonthNumber)
{
return(SqlConnector.GetFlightByMonth(MonthNumber));
}
public FlightModel FlightByID(int FlightID)
{
return(SqlConnector.GetFlightByID(FlightID));
}
public FlightModel FlightByDate(string BookDate)
{
return(SqlConnector.GetFlightByDate(BookDate));
}
public IEnumerable <FlightModel> Get()
{
return(SqlConnector.GetFlights_All());
}
public static void StartSqlDependencyAndEnableBrocker()
{
if (!WithSqlDependency)
{
started = true;
return;
}
lock (startKeyLock)
{
SqlConnector connector = (SqlConnector)Connector.Current;
if (DropStaleServices)
{
//to avoid massive logs with SqlQueryNotificationStoredProcedure
//http://rusanu.com/2007/11/10/when-it-rains-it-pours/
var staleServices = (from s in Database.View <SysServiceQueues>()
where s.activation_procedure != null && !Database.View <SysProcedures>().Any(p => "[" + p.Schema().name + "].[" + p.name + "]" == s.activation_procedure)
select new ObjectName(new SchemaName(null, s.Schema().name), s.name)).ToList();
foreach (var s in staleServices)
{
TryDropService(s.Name);
TryDropQueue(s);
}
var oldProcedures = (from p in Database.View <SysProcedures>()
where p.name.Contains("SqlQueryNotificationStoredProcedure-") && !Database.View <SysServiceQueues>().Any(s => "[" + p.Schema().name + "].[" + p.name + "]" == s.activation_procedure)
select new ObjectName(new SchemaName(null, p.Schema().name), p.name)).ToList();
foreach (var item in oldProcedures)
{
Executor.ExecuteNonQuery(new SqlPreCommandSimple($"DROP PROCEDURE {item.ToString()}"));
}
}
foreach (var database in Schema.Current.DatabaseNames())
{
SqlConnector sub = connector.ForDatabase(database);
try
{
try
{
SqlDependency.Start(sub.ConnectionString);
}
catch (InvalidOperationException ex)
{
string databaseName = database?.ToString() ?? Connector.Current.DatabaseName();
if (ex.Message.Contains("SQL Server Service Broker"))
{
EnableOrCreateBrocker(databaseName);
SqlDependency.Start(sub.ConnectionString);
}
}
}
catch (SqlException e)
{
if (e.Number == 2797)
{
string currentUser = (string)Executor.ExecuteDataTable("SELECT CURRENT_USER").Rows[0][0];
Executor.ExecuteNonQuery("ALTER USER [{0}] WITH DEFAULT_SCHEMA = dbo;".FormatWith(currentUser));
SqlDependency.Start(sub.ConnectionString);
}
else
{
throw e;
}
}
}
RegisterOnShutdown();
started = true;
}
}
public IssueData Get(long id)
{
return(SqlConnector.GetIssue(id));
}
public void Post([FromBody] TelemetryErrorData Data, string Version, string IpAddress)
{
SqlConnector.PostErrorData(Data, Version, IpAddress);
}
public object Post(IssueData Issue)
{
long IssueId = SqlConnector.AddIssue(Issue);
return(new { Id = IssueId });
}
static void Main(string[] args)
{
Console.WriteLine("TransactionEngine - I do as I told");
// Init
var unitConverion = new Nethereum.Util.UnitConversion();
var kv = new KeyVault(ConfigurationManager.AppSettings["AzureKeyVaultUri"],
ConfigurationManager.AppSettings["applicationId"],
ConfigurationManager.AppSettings["applicationSecret"]);
var encryptionKeyName = ConfigurationManager.AppSettings["EncryptionKeyName"];
var decryptionKeyName = ConfigurationManager.AppSettings["DecryptionKeyName"];
var signKeyName = ConfigurationManager.AppSettings["SignKeyName"];
var verifyKeyName = ConfigurationManager.AppSettings["VerifyKeyName"];
var encryptionCertPassword = ConfigurationManager.AppSettings["EncryptionCertPassword"];
var decryptionCertPassword = ConfigurationManager.AppSettings["DecryptionCertPassword"];
var signCertPassword = ConfigurationManager.AppSettings["SignCertPassword"];
var verifyCertPassword = ConfigurationManager.AppSettings["VerifyCertPassword"];
var secretsMgmnt =
new KeyVaultCryptoActions(
new CertificateInfo(encryptionKeyName, encryptionCertPassword),
new CertificateInfo(decryptionKeyName, decryptionCertPassword),
new CertificateInfo(signKeyName, signCertPassword),
new CertificateInfo(verifyKeyName, verifyCertPassword),
kv,
kv);
secretsMgmnt.InitializeAsync().Wait();
//var securedComm = new RabbitMQBusImpl(ConfigurationManager.AppSettings["rabbitMqUri"], secretsMgmnt, true, "securedCommExchange");
var queueClient =
new CloudQueueClientWrapper(ConfigurationManager.AppSettings["AzureStorageConnectionString"]);
var securedCommForTransactions = new AzureQueue("transactions", queueClient, secretsMgmnt, true);
var securedCommForNotifications = new AzureQueue("notifications", queueClient, secretsMgmnt, true);
var taskInitTransactions = securedCommForTransactions.InitializeAsync();
var taskInitNotifications = securedCommForNotifications.InitializeAsync();
Task.WhenAll(taskInitTransactions, taskInitNotifications).Wait();
var sqlDb = new SqlConnector(ConfigurationManager.AppSettings["SqlUserID"],
ConfigurationManager.AppSettings["SqlPassword"],
ConfigurationManager.AppSettings["SqlInitialCatalog"],
ConfigurationManager.AppSettings["SqlDataSource"],
ConfigurationManager.AppSettings["applicationId"],
ConfigurationManager.AppSettings["applicationSecret"]);
sqlDb.Initialize().Wait();
var ethereumNodeWrapper = new EthereumAccount(sqlDb, ConfigurationManager.AppSettings["EthereumNodeUrl"]);
// Listen on transactions requests, process them and notify the users when done
securedCommForTransactions.DequeueAsync(
msg =>
{
Console.WriteLine("Got work!");
var data = Communication.Utils.FromByteArray <string>(msg);
var msgArray = data.Split(';');
var amount = unitConverion.ToWei(msgArray[0]);
var senderName = msgArray[1];
var reciverAddress = msgArray[2];
try
{
var transactionHash = ethereumNodeWrapper
.SignTransactionAsync(senderName, reciverAddress, amount).Result;
var transactionResult = ethereumNodeWrapper.SendRawTransactionAsync(transactionHash).Result;
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
// Wait for miner
Thread.Sleep(3000);
// notify a user about his balance change
securedCommForNotifications.EnqueueAsync(Communication.Utils.ToByteArray(reciverAddress)).Wait();
},
(message) => { Console.WriteLine("Verification failure, doing nothing"); },
TimeSpan.FromSeconds(3)).Wait();
}
public List <IssueBuildData> Get(long IssueId)
{
return(SqlConnector.GetBuilds(IssueId));
}
public List <string> Get(long IssueId)
{
return(SqlConnector.GetWatchers(IssueId));
}
public List <IssueDiagnosticData> Get(long IssueId)
{
return(SqlConnector.GetDiagnostics(IssueId));
}
public void Post(long IssueId, [FromBody] IssueWatcherData Data)
{
SqlConnector.AddWatcher(IssueId, Data.UserName);
}
public IssueBuildData Get(long BuildId)
{
return(SqlConnector.GetBuild(BuildId));
}
public void Delete(long IssueId, [FromBody] IssueWatcherData Data)
{
SqlConnector.RemoveWatcher(IssueId, Data.UserName);
}
public LatestData Get(string Project = null)
{
return(SqlConnector.GetLastIds(Project));
}
public List <IssueData> Get(bool IncludeResolved = false, int MaxResults = -1)
{
return(SqlConnector.GetIssues(IncludeResolved, MaxResults));
}
public void Post([FromBody] EventData Event)
{
SqlConnector.PostEvent(Event);
}
public List <IssueData> Get(string User)
{
return(SqlConnector.GetIssues(User));
}
private void DropDatabase(SqlConnector newDatabase)
{
DisconnectedTools.DropDatabase(new DatabaseName(null, newDatabase.DatabaseName()));
}
/// <summary>
/// Connects the bot to the SQL database.
/// </summary>
private SqlConnector ConnectDatabase(Backend backend)
{
var sqlConnector = new SqlConnector();
Logger.Log(this, "Connecting to the database", LogLevel.Info);
try
{
if (sqlConnector.OpenConnection(backend.ConnectionString))
Logger.Log(this, "Database connection established", LogLevel.Info);
else
Logger.Log(this, "Database connection not established. Statistics collection will not be possible.", LogLevel.Warning);
}
catch (Exception e)
{
Logger.LogException(this, e, "trying to connect to the database");
}
return sqlConnector;
}
