public async Task <ActionResult <WineModel> > GetWine(int id)
{
Cql cql = new($"WHERE id=? allow filtering", id);
return(await CassandraConnection.GetInstance().GetRecord <WineModel>(cql)
.ConfigureAwait(false));
}
virtual public void Connect(Session owner, bool moveNext, out int streamId)
{
if (_hostsIter == null)
{
_hostsIter = owner.Policies.LoadBalancingPolicy.NewQueryPlan(Statement).GetEnumerator();
if (!_hostsIter.MoveNext())
{
var ex = new NoHostAvailableException(new Dictionary <IPAddress, List <Exception> >());
_logger.Error(ex);
throw ex;
}
}
else
{
if (moveNext)
{
if (!_hostsIter.MoveNext())
{
var ex = new NoHostAvailableException(InnerExceptions);
_logger.Error(ex);
throw ex;
}
}
}
Connection = owner.Connect(_hostsIter, TriedHosts, InnerExceptions, out streamId);
}
public IActionResult Index([FromQuery] string k)
{
// Create the return object
QueryResult queryResult = new QueryResult()
{
URL = null
};
// Return empty if no key specified in query string
if (k == null || k == string.Empty)
{
return(View(queryResult));
}
// Make a connection to Cassandra and get a session
CassandraConnection cassandraConnection = new CassandraConnection();
ISession csSession = cassandraConnection.GetSession();
URLLookup urlLookup = new URLLookup(csSession);
// Get the actual long URL
if (!urlLookup.LookupURL(k, out string url))
{
// Return NotFound page if key doesn't exist
return(NotFound());
}
// Attache the URL to the result object
queryResult.URL = url;
// Return result
return(View(queryResult));
}
public async Task <UserModel> GetUser(int id)
{
Cql cql = new($"SELECT * FROM {tableName} WHERE userid=?", id);
return(await CassandraConnection.GetInstance().GetRecord <UserModel>(cql)
.ConfigureAwait(false));
}
/// <summary>
/// Retrieve data for recommendation
/// </summary>
/// <param name="cql">Cql request</param>
/// <returns>List of wines</returns>
public static async Task <List <WineModel> > GetWineData(Cql cql, int limit)
{
var result = await CassandraConnection.GetInstance()
.GetByRequestData <WineModel>(cql);
return(new List <WineModel>().CopyElements(result, limit));
}
public void CreateAnswers_WhenSendAValidObject_ShouldCreateAndReturnObject()
{
var connectionMock = new CassandraConnection("answers", "localhost");
var mapperMock = new Mock <IMapper>();
var expected = new EvaluationScore()
{
Id = Guid.NewGuid(),
IdEvaluation = Guid.NewGuid(),
Qualification = Guid.NewGuid(),
Date = DateTime.Now,
Name = "TestName",
Owner = "TestOwner",
Score = 50,
ScoreFormula = "Formula",
Weight = 12,
QuestionList = new List <QuestionScore>()
{
new QuestionScore()
{
IdQuestion = Guid.NewGuid(),
Answers = new List <Guid>(),
Score = 5,
ScoreFormula = "QS1",
OptionList = new List <OptionScore>()
{
new OptionScore()
{
IdOption = Guid.NewGuid(), IsAnswer = true, Sequence = 1, UserSelected = false, Weight = 3
}
}
},
new QuestionScore()
{
IdQuestion = Guid.NewGuid(),
Answers = new List <Guid>(),
Score = 5,
ScoreFormula = "QS2",
OptionList = new List <OptionScore>()
},
},
QualificationRanges = new List <QualificationRange>()
{
new QualificationRange()
{
Id = Guid.NewGuid(), Start = 100, End = 0, Qualification = "GOOD"
}
},
};
mapperMock.Setup(m => m.Insert(expected, null)).Verifiable();
mapperMock.Setup(m => m.Single <EvaluationScore>(It.IsAny <string>(), It.IsAny <Guid>())).Returns(expected);
var answerDao = new AnswersDao(MockUtils.MockConnectionFactory(mapperMock));
var response = answerDao.CreateAnswers(expected);
Assert.Equal(expected.Id, response.Id);
}
public UserRepository()
{
const string getUserByName = "SELECT * FROM users WHERE username = :username";
const string createUser = "******";
_cassandraConnection = CassandraConnection.GetInstance();
_getUserByName = _cassandraConnection.PreparedStatement(getUserByName);
_createUser = _cassandraConnection.PreparedStatement(createUser);
}
public BlogRepository()
{
const string getAllBlogs = "SELECT * FROM blogs";
const string createBlog = "INSERT INTO blogs (id, content, date, title, writer) VALUES (now(), :content, :date, :title, :writer)";
_cassandraConnection = CassandraConnection.GetInstance();
_userRepository = new UserRepository();
_getAllBlogs = _cassandraConnection.PreparedStatement(getAllBlogs);
_createBlog = _cassandraConnection.PreparedStatement(createBlog);
}
public HttpResponseMessage Reset()
{
var connection = CassandraConnection.GetInstance();
foreach (var table in connection.GetTables())
{
connection.ExecuteNonReader($"TRUNCATE TABLE {CassandraConnection.KeySpace}.{table}");
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
/// <summary>
/// Retrieve selected wines from DB by their IDs
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public static async Task <List <WineModel> > GetSelectedData(int[] ids)
{
List <WineModel> selectedWines = new List <WineModel>();
foreach (int id in ids)
{
Cql cql = new("WHERE id=? allow filtering", id);
selectedWines.Add(await CassandraConnection.GetInstance().GetRecord <WineModel>(cql));
}
return(selectedWines);
}
public async Task <IEnumerable <WineModel> > GetWines([FromQuery] int page)
{
int startIndex = _pageSize * (page - 1);
Cql cql = new($"SELECT * FROM {_tableName} where id >= ? and id < ? allow filtering", startIndex, startIndex + _pageSize);
var temp = await CassandraConnection.GetInstance().GetByRequestData <WineModel>(cql);
List <WineModel> result = temp.ToList().OrderBy(wine => wine.Id).ToList();
return(result);
}
public async Task UpdateUserInfo(int id, string name, string email)
{
Cql cql = new("WHERE userid=?", id);
var user = await CassandraConnection.GetInstance().GetRecord <UserModel>(cql)
.ConfigureAwait(false);
UserModel newUser = new UserModel {
Email = email,
Name = name,
UserId = user.UserId,
Password = user.Password
};
await CassandraConnection.GetInstance().UpdateRecord(newUser)
.ConfigureAwait(false);
}
public async Task <JsonResult> GetFilteredWinesByPage(string color, string wine_type, string country, string vintage, int page)
{
Cql cql = new(WineControllerHelper.GenerateFilterCql(_tableName, color, wine_type, country, vintage));
var tempList = (await CassandraConnection.GetInstance().GetByRequestData <WineModel> (cql)).ToList();
List <WineModel> sortedResult = tempList.OrderBy(a => a.Id).ToList();
int startIndex = _pageSize * (page - 1);
int endIndex = startIndex + _pageSize;
var pagedList = new List <WineModel>();
int loopEndIndex = endIndex > tempList.Count ? tempList.Count : endIndex;
for (int i = startIndex; i < loopEndIndex; i++)
{
pagedList.Add(sortedResult[i]);
}
return(new JsonResult(new FilterResult()
{
WineList = pagedList,
Count = tempList.Count
}));
}
public async Task <int> GetNumberOfWines()
{
Cql cql = new($"select id from {_tableName}");
return(await CassandraConnection.GetInstance().GetNumberOfRecords <WineModel>(cql));
}
public async Task DeleteUser(int id)
{
Cql cql = new("WHERE userid=?", id);
await CassandraConnection.GetInstance().DeleteRecord <UserModel>(cql)
.ConfigureAwait(false);
}
public async Task AddUser(UserModel user)
{
await CassandraConnection.GetInstance().AddRecord(user)
.ConfigureAwait(false);
}
public object Index([FromForm] string url)
{
// Create object to return
APIResult result = new APIResult()
{
Status = (int)APIStatus.Failure,
Message = "",
URL = url,
Shortcut = string.Empty,
Popularity = 0
};
// Get the URL's SHA512 & SHA256 hash
string sha512 = SHA512Hash.GetSHA512Hash(url);
string sha256 = SHA256Hash.GetSHA256Hash(url);
// Open up a connection to Cassandra
CassandraConnection csConnection = new CassandraConnection();
// Get connection session
ISession csSession = csConnection.GetSession();
// Lookup database and return the URL's signature if it exists
SignatureLookup signatureLookup = new SignatureLookup(csSession);
if (signatureLookup.LookupSignature(sha512, sha256, out string signature, out long hits))
{
result.Shortcut = this.MakeShortcut(signature);
result.Popularity = hits;
result.Status = (int)APIStatus.Success;
return(Json(result));
}
// Get total URL count from the running service
long id = 0;
try
{
const string BOT = "<~BOT~>";
const string EOT = "<~EOT~>";
const string COMMAND_COUNT = "COUNT";
string message = string.Format("{0}{1}{2}", BOT, COMMAND_COUNT, EOT);
string ip = "127.0.0.1";
int port = 7079;
AsyncClientSocket asyncClientSocket = new AsyncClientSocket();
asyncClientSocket.Transmit(ip, port, message, out string response);
//SyncClientSocket.Transmit(ip, port, message, out string response);
if (response == string.Empty)
{
result.Message = "Service Unavailable!";
return(Json(result));
}
id = long.Parse(response);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
// Prepare dictionary
char[] dictionary =
{
'A', 'B', 'C', 'D', 'E', 'F',
'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x',
'y', 'z',
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9'
};
// Get signature
signature = BaseN.ChangeBase(id, dictionary);
// Unique signature is now set
result.Shortcut = this.MakeShortcut(signature);
// Insert the new URL into the database
URLInsertion urlInsertion = new URLInsertion(csSession);
if (urlInsertion.InsertURL(url, signature, sha512, sha256))
{
result.Popularity = 1;
result.Status = (int)APIStatus.Success;
}
return(Json(result));
}
static void Main(string[] args)
{
DateTime start = Config.ParseDateTimeLocal(args[0]);
DateTime end = Config.ParseDateTimeLocal(args[1]);
PROBLEM pb = (PROBLEM)Enum.Parse(typeof(PROBLEM), args[2]);
Dictionary <string, string> dicSettings = new Dictionary <string, string>();
dicSettings["APP_NAME"] = "Midax";
dicSettings["LIMIT"] = "10";
dicSettings["DB_CONTACTPOINT"] = "192.168.1.25";
dicSettings["REPLAY_MODE"] = "CSV";
dicSettings["TRADING_MODE"] = "CALIBRATION";
Config.Settings = dicSettings;
// read market data and indicator values
var marketData = new Dictionary <string, List <CqlQuote> >();
var indicatorData = new Dictionary <string, List <CqlQuote> >();
var profitData = new Dictionary <string, List <double> >();
string[] ids = new string[1];
ids[0] = "CS.D.EURUSD.TODAY.IP";
while (start <= end)
{
List <string> mktdataFiles = new List <string>();
mktdataFiles.Add(string.Format("..\\..\\..\\MarketSelector\\MktSelectorData\\mktselectdata_{0}_{1}_{2}.csv", start.Day, start.Month, start.Year));
Config.Settings["REPLAY_CSV"] = Config.TestList(mktdataFiles);
Config.Settings["PUBLISHING_START_TIME"] = string.Format("{0}-{1}-{2} {3}:{4}:{5}", start.Year, start.Month, start.Day, 6, 45, 0);
Config.Settings["PUBLISHING_STOP_TIME"] = string.Format("{0}-{1}-{2} {3}:{4}:{5}", start.Year, start.Month, start.Day, 18, 0, 0);
Config.Settings["TRADING_START_TIME"] = string.Format("{0}-{1}-{2} {3}:{4}:{5}", start.Year, start.Month, start.Day, 8, 0, 0);
Config.Settings["TRADING_STOP_TIME"] = string.Format("{0}-{1}-{2} {3}:{4}:{5}", start.Year, start.Month, start.Day, 17, 0, 0);
Config.Settings["TRADING_CLOSING_TIME"] = string.Format("{0}-{1}-{2} {3}:{4}:{5}", start.Year, start.Month, start.Day, 16, 55, 0);
//Config.Settings["PUBLISHING_CSV"] = string.Format("..\\..\\CalibrationData\\calibdata_{0}_{1}_{2}.csv", start.Day, start.Month, start.Year);
var client = new ReplayStreamingClient();
client.Connect();
Dictionary <string, List <CqlQuote> > curDayMktData = client.GetReplayData(ids);
foreach (var keyVal in curDayMktData)
{
var processableMktData = new List <CqlQuote>();
foreach (var quote in keyVal.Value)
{
if (client.ExpectedIndicatorData["EMA_90_" + ids[0]].Select(cqlq => cqlq.t).Contains(quote.t))
{
processableMktData.Add(quote);
}
}
if (marketData.ContainsKey(keyVal.Key))
{
marketData[keyVal.Key].AddRange(processableMktData);
}
else
{
marketData[keyVal.Key] = processableMktData;
}
}
foreach (var keyVal in client.ExpectedIndicatorData)
{
if (indicatorData.ContainsKey(keyVal.Key))
{
indicatorData[keyVal.Key].AddRange(keyVal.Value);
}
else
{
indicatorData[keyVal.Key] = keyVal.Value;
}
}
foreach (var keyVal in client.ExpectedProfitData)
{
if (!profitData.ContainsKey(keyVal.Key.Key))
{
profitData[keyVal.Key.Key] = new List <double>();
}
profitData[keyVal.Key.Key].Add(keyVal.Value);
}
// process next day
do
{
start = start.AddDays(1);
}while (start.DayOfWeek == DayOfWeek.Saturday || start.DayOfWeek == DayOfWeek.Sunday);
}
NeuralNetworkForCalibration ann = null;
var maxError = 1e-5;
switch (pb)
{
case PROBLEM.PARITY:
ann = new NeuralNetworkParity("Parity-3");
ann.Train();
break;
case PROBLEM.WMA:
ann = new NeuralNetworkWMA_5_2(ids[0], marketData, indicatorData, profitData);
maxError = 5.0;
break;
case PROBLEM.FX:
ann = new NeuralNetworkFX(ids[0], marketData, indicatorData, profitData);
maxError = 5.0;
break;
}
if (ann == null)
{
MessageBox.Show("Could not instanciate the Neural Network", "Error");
}
else
{
using (AnnVisualizer visualizer = new AnnVisualizer(ann))
{
ann.Train(maxError);
CassandraConnection DBconnection = (CassandraConnection)PublisherConnection.Instance.Database;
if (ann.Version > 0)
{
var prevError = DBconnection.GetAnnError(ann.AnnId, ann.StockId, ann.Version - 1);
var prevLearningRate = DBconnection.GetAnnLearningRate(ann.AnnId, ann.StockId, ann.Version - 1);
DialogResult dialogResult = MessageBox.Show(string.Format("The calibration error is {0} (Previously was {1}).\n The learning rate is {2}% (Previously was {3}).\n Would you like to publish the weights to production DB?",
ann.Error, prevError, ann.LearningRatePct, prevLearningRate), ann.GetType().ToString(), MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
PublisherConnection.Instance.Insert(DateTime.Now, ann);
}
}
else
{
DialogResult dialogResult = MessageBox.Show(string.Format("The calibration error is {0}.\n The learning rate is {1}%.\n Would you like to publish the weights to production DB?",
ann.Error, ann.LearningRatePct), ann.GetType().ToString(), MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
PublisherConnection.Instance.Insert(DateTime.Now, ann);
}
}
}
}
}
