public void Initialize()
{
_log.Info($"Server is initialisizing ...");
//create data db if it doesn't exist
DataDBContext dataContext;
try
{
dataContext = new DataDBContext(_config.LocalStorage.ConnectionString);
dataContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context DataDB!", ex);
}
dataContext.Dispose();
MyDBContext entityContext;
try
{
entityContext = new MyDBContext();
entityContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context MyDB!", ex);
}
_log.Info($"Server is ready.");
}
private List <ProductViewModel> GetProducts(int currentPage)
{
int maxRows = 10;
using (dBContext = new DataDBContext())
{
List <ProductViewModel> model = new List <ProductViewModel>();
model = (from p in dBContext.Products
join c in dBContext.Categories on p.CategoryId equals c.CategoryId
select new ProductViewModel
{
ProductId = p.ProductId,
ProductName = p.ProductName,
CategoryId = c.CategoryId,
CategoryName = c.CategoryName
})
.OrderBy(product => product.ProductId)
.Skip((currentPage - 1) * maxRows)
.Take(maxRows).ToList();
double pageCount = (double)((decimal)dBContext.Products.Count() / Convert.ToDecimal(maxRows));
ViewBag.PageCount = (int)Math.Ceiling(pageCount);
ViewBag.CurrentPageIndex = currentPage;
return(model);
}
}
private void CreateDatabases()
{
//create metadata db if it doesn't exist
var entityContext = new MyDBContext();
entityContext.Database.Initialize(false);
//seed the datasources no matter what, because these are added frequently
Seed.SeedDatasources(entityContext);
//check for any exchanges, seed the db with initial values if nothing is found
if (!entityContext.Exchanges.Any() ||
(ApplicationDeployment.IsNetworkDeployed && ApplicationDeployment.CurrentDeployment.IsFirstRun))
{
Seed.DoSeed();
}
entityContext.Dispose();
//create data db if it doesn't exist
var dataContext = new DataDBContext();
dataContext.Database.Initialize(false);
dataContext.Dispose();
//create quartz db if it doesn't exist
QuartzUtils.InitializeDatabase(Settings.Default.databaseType);
}
//private Instrument selectedInstrument;
public MainWindowViewModel(MenuItem sessionMenuItem, MenuItem tagMenuItem)
{
SessionMenuItem = sessionMenuItem;
TagMenuItem = tagMenuItem;
MappingConfiguration.Register();
CreateBrokers();
CreateAndStartServers();
ActiveStreams = RealTimeBroker.ActiveStreams;
DbContext.Database.Initialize(false);
Seed.SeedDatasources(DbContext);
if (!DbContext.Exchanges.Any())
{
Seed.DoSeed();
}
//create data db if it doesn't exist
var dataContext = new DataDBContext();
dataContext.Database.Initialize(false);
dataContext.Dispose();
//we also need a client to make historical data requests with
CreateAndStartClient();
GetInstruments();
CreateCommands();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, DataDBContext context)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc();
context.Database.EnsureCreated();//数据库不存在的话，会自动创建
}
public void SqlServerDbIsCreatedSuccessfully()
{
using (var conn = new SqlConnection(GetSqlServerConnString("master", _sqlServerHost, _sqlServerUsername, _sqlServerPassword, false, _useWindowsAuthentication)))
{
conn.Open();
using (var cmd = new SqlCommand("", conn))
{
cmd.CommandText = @"IF EXISTS(SELECT name FROM sys.databases WHERE name = 'qdms_test')
DROP DATABASE qdms_test";
cmd.ExecuteNonQuery();
cmd.CommandText = @"IF EXISTS(SELECT name FROM sys.databases WHERE name = 'qdmsdata_test')
DROP DATABASE qdmsdata_test";
cmd.ExecuteNonQuery();
cmd.CommandText = "CREATE DATABASE qdms_test";
cmd.ExecuteNonQuery();
cmd.CommandText = "CREATE DATABASE qdmsdata_test";
cmd.ExecuteNonQuery();
}
}
SetConnectionString("qdmsEntities", GetSqlServerConnString("qdms_test", _sqlServerHost, _sqlServerUsername, _sqlServerPassword, false, _useWindowsAuthentication), "System.Data.SqlClient");
SetConnectionString("qdmsDataEntities", GetSqlServerConnString("qdmsdata_test", _sqlServerHost, _sqlServerUsername, _sqlServerPassword, false, _useWindowsAuthentication), "System.Data.SqlClient");
ConfigurationManager.RefreshSection("connectionStrings");
using (var ctx = new MyDBContext())
{
ctx.Database.Initialize(true);
Seed.SeedDatasources(ctx);
Seed.DoSeed();
}
using (var ctx = new DataDBContext())
{
ctx.Database.Initialize(true);
}
}
public void MySqlDbIsCreatedSuccessfully()
{
using (var conn = new MySqlConnection(GetMySqlConnString(_mySqlUsername, _mySqlPassword, _mySqlHost)))
{
conn.Open();
using (var cmd = new MySqlCommand("", conn))
{
cmd.CommandText = @"DROP DATABASE IF EXISTS qdms_test;
CREATE DATABASE qdms_test;
DROP DATABASE IF EXISTS qdmsdata_test;
CREATE DATABASE qdmsdata_test;";
cmd.ExecuteNonQuery();
}
}
SetConnectionString("qdmsEntities", GetMySqlConnString(_mySqlUsername, _mySqlPassword, _mySqlHost, "qdms_test"), "MySql.Data.MySqlClient");
SetConnectionString("qdmsDataEntities", GetMySqlConnString(_mySqlUsername, _mySqlPassword, _mySqlHost, "qdmsdata_test"), "MySql.Data.MySqlClient");
ConfigurationManager.RefreshSection("connectionStrings");
DbConfiguration.SetConfiguration(new MySqlEFConfiguration());
using (var ctx = new MyDBContext())
{
ctx.Database.Initialize(true);
Seed.SeedDatasources(ctx);
Seed.DoSeed();
}
using (var ctx = new DataDBContext())
{
ctx.Database.Initialize(true);
}
}
public DatingRepository(DataDBContext context)
{
_context = context;
}
public CategoryController()
{
dBContext = new DataDBContext();
}
public CustomerController(DataDBContext context)
{
_context = context;
}
public PaymentsController(DataDBContext context)
{
_context = context;
}
public PlansController(UserManager <User> u, DataDBContext d, AuthenticationDBContext a)
{
manager = u;
data = d;
auth = a;
}
public SearchController(DataDBContext dataDBContext)
{
this.dbContext = dataDBContext;
microMiner = new Microminer(dbContext);
}
public UserDetailController(DataDBContext _context)
{
context = _context;
}
public MainWindow()
{
Common.Logging.LogManager.Adapter = new NLogLoggerFactoryAdapter(new Common.Logging.Configuration.NameValueCollection());
//make sure we can connect to the database
CheckDBConnection();
//set the log directory
SetLogDirectory();
//set the connection string
DBUtils.SetConnectionString();
//set EF configuration, necessary for MySql to work
DBUtils.SetDbConfiguration();
InitializeComponent();
DataContext = this;
//load datagrid layout
string layoutFile = AppDomain.CurrentDomain.BaseDirectory + "GridLayout.xml";
if (File.Exists(layoutFile))
{
try
{
InstrumentsGrid.DeserializeLayout(File.ReadAllText(layoutFile));
}
catch
{
}
}
LogMessages = new ConcurrentNotifierBlockingList <LogEventInfo>();
//target is where the log managers send their logs, here we grab the memory target which has a Subject to observe
var target = LogManager.Configuration.AllTargets.Single(x => x.Name == "myTarget") as MemoryTarget;
//Log unhandled exceptions
AppDomain.CurrentDomain.UnhandledException += AppDomain_CurrentDomain_UnhandledException;
//we subscribe to the messages and send them all to the LogMessages collection
if (target != null)
{
target.Messages.Subscribe(msg => LogMessages.TryAdd(msg));
}
//build the instruments grid context menu
//we want a button for each BarSize enum value in the UpdateFreqSubMenu menu
foreach (int value in Enum.GetValues(typeof(BarSize)))
{
var button = new MenuItem
{
Header = Regex.Replace(((BarSize)value).ToString(), "([A-Z])", " $1").Trim(),
Tag = (BarSize)value
};
button.Click += UpdateHistoricalDataBtn_ItemClick;
((MenuItem)Resources["UpdateFreqSubMenu"]).Items.Add(button);
}
//create metadata db if it doesn't exist
var entityContext = new MyDBContext();
entityContext.Database.Initialize(false);
//seed the datasources no matter what, because these are added frequently
Seed.SeedDatasources(entityContext);
//check for any exchanges, seed the db with initial values if nothing is found
if (!entityContext.Exchanges.Any())
{
Seed.DoSeed();
}
//create data db if it doesn't exist
var dataContext = new DataDBContext();
dataContext.Database.Initialize(false);
dataContext.Dispose();
//create quartz db if it doesn't exist
QuartzUtils.InitializeDatabase(Settings.Default.databaseType);
//build the tags menu
var allTags = entityContext.Tags.ToList();
BuildTagContextMenu(allTags);
//build session templates menu
BuildSetSessionTemplateMenu();
Instruments = new ObservableCollection <Instrument>();
var instrumentRepo = new InstrumentRepository(entityContext);
var instrumentList = instrumentRepo.FindInstruments().Result;
foreach (Instrument i in instrumentList)
{
Instruments.Add(i);
}
//create brokers
var cfRealtimeBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient(
"RTDBCFClient",
"127.0.0.1",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.hDBPort,
Properties.Settings.Default.httpPort,
Properties.Settings.Default.apiKey,
useSsl: Properties.Settings.Default.useSsl),
connectImmediately: false);
var cfHistoricalBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient(
"HDBCFClient",
"127.0.0.1",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.hDBPort,
Properties.Settings.Default.httpPort,
Properties.Settings.Default.apiKey,
useSsl: Properties.Settings.Default.useSsl),
connectImmediately: false);
var localStorage = DataStorageFactory.Get();
RealTimeBroker = new RealTimeDataBroker(cfRealtimeBroker, localStorage,
new IRealTimeDataSource[] {
//new Xignite(Properties.Settings.Default.xigniteApiToken),
//new Oanda(Properties.Settings.Default.oandaAccountId, Properties.Settings.Default.oandaAccessToken),
new IB(Properties.Settings.Default.ibClientHost, Properties.Settings.Default.ibClientPort, Properties.Settings.Default.rtdClientIBID),
//new ForexFeed(Properties.Settings.Default.forexFeedAccessKey, ForexFeed.PriceType.Mid)
});
HistoricalBroker = new HistoricalDataBroker(cfHistoricalBroker, localStorage,
new IHistoricalDataSource[] {
new Yahoo(),
new FRED(),
//new Forexite(),
new IB(Properties.Settings.Default.ibClientHost, Properties.Settings.Default.ibClientPort, Properties.Settings.Default.histClientIBID),
new Quandl(Properties.Settings.Default.quandlAuthCode),
new BarChart(Properties.Settings.Default.barChartApiKey)
});
var countryCodeHelper = new CountryCodeHelper(entityContext.Countries.ToList());
EconomicReleaseBroker = new EconomicReleaseBroker("FXStreet",
new[] { new fx.FXStreet(countryCodeHelper) });
//create the various servers
_realTimeServer = new RealTimeDataServer(Properties.Settings.Default.rtDBPubPort, Properties.Settings.Default.rtDBReqPort, RealTimeBroker);
_historicalDataServer = new HistoricalDataServer(Properties.Settings.Default.hDBPort, HistoricalBroker);
//and start them
_realTimeServer.StartServer();
_historicalDataServer.StartServer();
//we also need a client to make historical data requests with
_client = new QDMSClient.QDMSClient(
"SERVERCLIENT",
"localhost",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.hDBPort,
Properties.Settings.Default.httpPort,
Properties.Settings.Default.apiKey,
useSsl: Properties.Settings.Default.useSsl);
_client.Connect();
_client.HistoricalDataReceived += _client_HistoricalDataReceived;
ActiveStreamGrid.ItemsSource = RealTimeBroker.ActiveStreams;
//create the scheduler
var quartzSettings = QuartzUtils.GetQuartzSettings(Settings.Default.databaseType);
ISchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzSettings);
_scheduler = schedulerFactory.GetScheduler();
_scheduler.JobFactory = new JobFactory(HistoricalBroker,
Properties.Settings.Default.updateJobEmailHost,
Properties.Settings.Default.updateJobEmailPort,
Properties.Settings.Default.updateJobEmailUsername,
Properties.Settings.Default.updateJobEmailPassword,
Properties.Settings.Default.updateJobEmailSender,
Properties.Settings.Default.updateJobEmail,
new UpdateJobSettings(
noDataReceived: Properties.Settings.Default.updateJobReportNoData,
errors: Properties.Settings.Default.updateJobReportErrors,
outliers: Properties.Settings.Default.updateJobReportOutliers,
requestTimeouts: Properties.Settings.Default.updateJobTimeouts,
timeout: Properties.Settings.Default.updateJobTimeout,
toEmail: Properties.Settings.Default.updateJobEmail,
fromEmail: Properties.Settings.Default.updateJobEmailSender),
localStorage,
EconomicReleaseBroker);
_scheduler.Start();
//Take jobs stored in the qmds db and move them to the quartz db - this can be removed in the next version
MigrateJobs(entityContext, _scheduler);
var bootstrapper = new CustomBootstrapper(
DataStorageFactory.Get(),
EconomicReleaseBroker,
HistoricalBroker,
RealTimeBroker,
Properties.Settings.Default.apiKey);
var uri = new Uri((Settings.Default.useSsl ? "https" : "http") + "://localhost:" + Properties.Settings.Default.httpPort);
var host = new NancyHost(bootstrapper, uri);
host.Start();
entityContext.Dispose();
ShowChangelog();
}
public void Initialisize()
{
_log.Info($"Server is initialisizing ...");
//create data db if it doesn't exist
DataDBContext dataContext;
try
{
dataContext = new DataDBContext(_config.LocalStorage.ConnectionString);
dataContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context DataDB!", ex);
}
dataContext.Dispose();
MyDBContext entityContext;
try
{
entityContext = new MyDBContext(_config.DataStorage.ConnectionString);
entityContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context MyDB!", ex);
}
// initialisize helper classes
_instrumentManager = new InstrumentManager();
var cfRealtimeBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient("RTDBCFClient", "127.0.0.1",
_config.RealtimeDataService.RequestPort, _config.RealtimeDataService.PublisherPort,
_config.InstrumentService.Port, _config.HistoricalDataService.Port), _instrumentManager, false);
var cfHistoricalBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient("HDBCFClient", "127.0.0.1",
_config.RealtimeDataService.RequestPort, _config.RealtimeDataService.PublisherPort,
_config.InstrumentService.Port, _config.HistoricalDataService.Port), _instrumentManager, false);
IDataStorage localStorage;
switch (_config.LocalStorage.Type)
{
case Config.LocalStorageType.MySql:
localStorage = new QDMSServer.DataSources.MySQLStorage(_config.LocalStorage.ConnectionString);
break;
case Config.LocalStorageType.SqlServer:
localStorage = new QDMSServer.DataSources.SqlServerStorage(_config.LocalStorage.ConnectionString);
break;
default:
throw new NotSupportedException("Not supported local storage type: " + _config.LocalStorage.Type);
}
// create brokers
_historicalDataBroker = new HistoricalDataBroker(cfHistoricalBroker, localStorage, new IHistoricalDataSource[] {
// @todo please add here some historical data sources the service should provide
});
_realTimeDataBroker = new RealTimeDataBroker(cfRealtimeBroker, localStorage, new IRealTimeDataSource[] {
// @todo please add here some real time data sources the service should provide
});
// create servers
_instrumentsServer = new InstrumentsServer(_config.InstrumentService.Port, _instrumentManager);
_historicalDataServer = new HistoricalDataServer(_config.HistoricalDataService.Port, _historicalDataBroker);
_realTimeDataServer = new RealTimeDataServer(_config.RealtimeDataService.PublisherPort, _config.RealtimeDataService.RequestPort, _realTimeDataBroker);
// ... start the servers
_instrumentsServer.StartServer();
_historicalDataServer.StartServer();
_realTimeDataServer.StartServer();
_log.Info($"Server is ready.");
}
public AuthController(DataDBContext d, AuthenticationDBContext a, UserManager <User> m)
{
data = d;
authentication = a;
manager = m;
}
public RoomFacilityTestController()
{
context = new DataDBContext(dbContextOptions);
}
public HotelRoomTestController()
{
context = new DataDBContext(dbContextOptions);
}
public HotelRepository(DataDBContext hotelData)
{
_context = hotelData;
}
public Microminer(DataDBContext dbContext)
{
dataManager = new DataManager(dbContext);
masterControl = new MasterControl();
}
public RoomFacilityController(DataDBContext context)
{
_context = context;
}
public ShowController(DataDBContext context)
{
dbContext = context;
}
public SafetyDocsController(DataDBContext context, AuthenticationDBContext a, UserManager <User> m)
{
data = context;
authentication = a;
manager = m;
}
public AuthRepo(DataDBContext context)
{
_context = context;
}
public ModifyController(DataDBContext context)
{
dbContext = context;
}
public MainWindow()
{
Common.Logging.LogManager.Adapter = new NLogLoggerFactoryAdapter(new Common.Logging.Configuration.NameValueCollection());
//make sure we can connect to the database
CheckDBConnection();
//set the log directory
SetLogDirectory();
//set the connection string
DBUtils.SetConnectionString();
//set EF configuration, necessary for MySql to work
DBUtils.SetDbConfiguration();
InitializeComponent();
//load datagrid layout
string layoutFile = AppDomain.CurrentDomain.BaseDirectory + "GridLayout.xml";
if (File.Exists(layoutFile))
{
try
{
InstrumentsGrid.DeserializeLayout(File.ReadAllText(layoutFile));
}
catch
{
}
}
//Log unhandled exceptions
AppDomain.CurrentDomain.UnhandledException += AppDomain_CurrentDomain_UnhandledException;
//build the instruments grid context menu
//we want a button for each BarSize enum value in the UpdateFreqSubMenu menu
foreach (int value in Enum.GetValues(typeof(BarSize)))
{
var button = new MenuItem
{
Header = Regex.Replace(((BarSize)value).ToString(), "([A-Z])", " $1").Trim(),
Tag = (BarSize)value
};
button.Click += UpdateHistoricalDataBtn_ItemClick;
((MenuItem)Resources["UpdateFreqSubMenu"]).Items.Add(button);
}
//create metadata db if it doesn't exist
var entityContext = new MyDBContext();
entityContext.Database.Initialize(false);
//seed the datasources no matter what, because these are added frequently
Seed.SeedDatasources(entityContext);
//check for any exchanges, seed the db with initial values if nothing is found
if (!entityContext.Exchanges.Any() ||
(ApplicationDeployment.IsNetworkDeployed && ApplicationDeployment.CurrentDeployment.IsFirstRun))
{
Seed.DoSeed();
}
//create data db if it doesn't exist
var dataContext = new DataDBContext();
dataContext.Database.Initialize(false);
dataContext.Dispose();
//create quartz db if it doesn't exist
QuartzUtils.InitializeDatabase(Settings.Default.databaseType);
//build the tags menu
var allTags = entityContext.Tags.ToList();
BuildTagContextMenu(allTags);
//build session templates menu
BuildSetSessionTemplateMenu();
entityContext.Dispose();
//we also need a client to make historical data requests with
_client = new QDMSClient.QDMSClient(
"SERVERCLIENT",
"localhost",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.hDBPort,
Properties.Settings.Default.httpPort,
Properties.Settings.Default.apiKey,
useSsl: Properties.Settings.Default.useSsl);
_client.HistoricalDataReceived += _client_HistoricalDataReceived;
_client.Error += (s, e) => _clientLogger.Error(e.ErrorMessage);
//Create ViewModel
ViewModel = new MainViewModel(_client, DialogCoordinator.Instance);
DataContext = ViewModel;
ShowChangelog();
}
public void Initialisize()
{
_log.Info($"Server is initialisizing ...");
//create data db if it doesn't exist
DataDBContext dataContext;
try
{
dataContext = new DataDBContext(_config.LocalStorage.ConnectionString);
dataContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context DataDB!", ex);
}
dataContext.Dispose();
MyDBContext entityContext;
try
{
entityContext = new MyDBContext(_config.DataStorage.ConnectionString);
entityContext.Database.Initialize(false);
}
catch (System.Data.Entity.Core.ProviderIncompatibleException ex)
{
throw new NotSupportedException("Could not connect to context MyDB!", ex);
}
// initialisize helper classes
var cfRealtimeBroker = new ContinuousFuturesBroker(GetClient("RTDBCFClient"), false);
var cfHistoricalBroker = new ContinuousFuturesBroker(GetClient("HDBCFClient"), false);
IDataStorage localStorage;
switch (_config.LocalStorage.Type)
{
case LocalStorageType.MySql:
localStorage = new QDMSServer.DataSources.MySQLStorage(_config.LocalStorage.ConnectionString);
break;
case LocalStorageType.SqlServer:
localStorage = new QDMSServer.DataSources.SqlServerStorage(_config.LocalStorage.ConnectionString);
break;
default:
throw new NotSupportedException("Not supported local storage type: " + _config.LocalStorage.Type);
}
// create brokers
_historicalDataBroker = new HistoricalDataBroker(cfHistoricalBroker, localStorage, new IHistoricalDataSource[] {
// @todo please add here some historical data sources the service should provide
});
_realTimeDataBroker = new RealTimeDataBroker(cfRealtimeBroker, localStorage, new IRealTimeDataSource[] {
// @todo please add here some real time data sources the service should provide
});
_economicReleaseBroker = new EconomicReleaseBroker("FXStreet",
new[] { new fx.FXStreet(new CountryCodeHelper(entityContext.Countries.ToList())) });
// create servers
_historicalDataServer = new HistoricalDataServer(_config.HistoricalDataService.Port, _historicalDataBroker);
_realTimeDataServer = new RealTimeDataServer(_config.RealtimeDataService.PublisherPort, _config.RealtimeDataService.RequestPort, _realTimeDataBroker);
// create scheduler
ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); //todo need settings for scheduler + jobfactory
_scheduler = schedulerFactory.GetScheduler();
var bootstrapper = new CustomBootstrapper(
localStorage,
_economicReleaseBroker,
_historicalDataBroker,
_realTimeDataBroker,
_scheduler,
_config.WebService.ApiKey);
var uri = new Uri((_config.WebService.UseSsl ? "https" : "http") + "://localhost:" + _config.WebService.Port);
_httpServer = new NancyHost(bootstrapper, uri);
// ... start the servers
_historicalDataServer.StartServer();
_realTimeDataServer.StartServer();
_httpServer.Start();
_scheduler.Start();
_log.Info($"Server is ready.");
}
public RegisterController(DataDBContext context)
{
dbContext = context;
}
public CallsController(DataDBContext d, AuthenticationDBContext a, UserManager <User> u)
{
data = d;
authentication = a;
manager = u;
}
