public SnapshotManagement(SqlRepository Repository)
{
_Repository = Repository;
_Server = new Server(
new ServerConnection(Repository.Connection)
);
}
static void ProcessSnapshots(string ConnectionString)
{
using (SqlRepository Repository = new SqlRepository(ConnectionString))
{
IEnumerable<Snapshot> SnapshotDbs =
Snapshot.GetSnapshots(Repository);
if (SnapshotDbs.Count() == 0 || !SnapshotDbs.Any<Snapshot>(x => x.Active == true))
{
Snapshot.Intialize(Repository);
return;
}
Snapshot ActiveSnapshot =
SnapshotDbs.FirstOrDefault<Snapshot>(x => x.Active == true);
Snapshot InactiveSnapshot =
SnapshotDbs.FirstOrDefault<Snapshot>(x => x.Active == false);
InactiveSnapshot.Activate(Repository);
ActiveSnapshot.Deactivate();
using(TransactionScope Scope = new TransactionScope())
{
InactiveSnapshot.Track(Repository);
ActiveSnapshot.Track(Repository);
Scope.Complete();
}
}
}
public static IEnumerable<Snapshot> GetSnapshots(SqlRepository Repository)
{
string Query =
"SELECT Name, Active FROM " + _SnapshotTable;
return Repository.Get<Snapshot>(Query, null, false);
}
public CollectionShooterDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_collectionshooter>(context);
_selector = colletionShooter => new CollectionShooter
{
ShooterId = colletionShooter.ShooterId,
CollectionShooterId = colletionShooter.CollectionShooterId,
ShooterCollectionId = colletionShooter.ShooterCollectionId
};
}
public void Test(string startsWith, string endsWith)
{
ISqlRepository repo = new SqlRepository("sqlDefaultConnection2");
var branches = repo.GetAll<Branche>();
var branch = repo.FindSingle<Branche>(b => b.Id == 1);
branches = repo.Find<Branche>(b => b.Address2.EndsWith(endsWith) && b.Name == "البيداء");
branches = repo.Find<Branche>(b => b.Address2.StartsWith(startsWith));
branches = repo.Find<Branche>(b => b.Address2 == null);
}
public ShooterNumberConfigDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_shooternumberconfig>(context);
_selector = shooterNumberConfig => new ShooterNumberConfig()
{
ShooterNumberConfigId = shooterNumberConfig.ShooterNumberConfigId,
LastGivenShooterNumber = shooterNumberConfig.LastGivenShooterNumber,
ShooterNumberIncrement = shooterNumberConfig.ShooterNumberIncrement
};
}
public ShooterParticipationDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_shooterparticipation>(context);
_selector = shooterParticipation => new ShooterParticipation()
{
ShooterParticipationId = shooterParticipation.ShooterParticipationId,
ProgramNumber = shooterParticipation.ProgramNumber,
ShooterId = shooterParticipation.ShooterId,
};
}
public ShooterCollectionDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_shootercollection>(context);
_selector = shooterCollection => new ShooterCollection
{
CollectionName = shooterCollection.CollectionName,
ShooterCollectionId = shooterCollection.ShooterCollectionId,
ProgramNumber = shooterCollection.ProgramNumber
};
}
public ShooterDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_shooter>(context);
_selector = shooter => new Shooter
{
ShooterId = shooter.ShooterId,
ShooterNumber = shooter.ShooterNumber,
PersonId = shooter.PersonId,
};
}
public SessionDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_session>(context);
_selector = session => new Session
{
SessionId = session.SessionId,
ProgramNumber = session.ProgramNumber,
LaneNumber = session.LaneNumber,
ShooterId = session.ShooterId,
};
}
public SessionSubtotalDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_sessionsubtotal>(context);
_selector = sessionSubtotal => new SubSession
{
SessionSubtotalId = sessionSubtotal.SessionSubtotalId,
SessionId = sessionSubtotal.SessionId,
Ordinal = sessionSubtotal.SubtotalOrdinal,
BestShotId = sessionSubtotal.BestShotId
};
}
public void Activate(SqlRepository Repository)
{
SnapshotManagement Management =
new SnapshotManagement(Repository);
Management.CreateSnaphot(
this.Name,
Repository.Connection.Database,
_SnapshotLocation
);
this.Active = true;
}
public string GetCode()
{
try
{
ISqlRepository sqlRepository = new SqlRepository(DesignerConnectionString);
return
$"{new Common(_config).GetCode()}{new TableValuedParameter(_config, sqlRepository).GetCode()}{new Enum(_config, sqlRepository).GetCode()}{new Procedure(_config, sqlRepository, _supportsAsync).GetCode()}";
}
catch
{
return "/* Unable to generate code due to empty or invalid configuration */";
}
}
public PersonDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_person>(context);
_selector = person => new Person
{
PersonId = person.PersonId,
FirstName = person.FirstName,
LastName = person.LastName,
Address = person.Street,
ZipCode = person.Zip,
City = person.City,
Email = person.Email,
Phone = person.Phone,
DateOfBirth = person.BirthDate,
};
}
ShippingMethod GetOrderShippingMethod(Commerce.Data.SqlRepository.ShippingMethod method, SqlRepository.Order order) {
ShippingMethod result = null;
Decimal orderWeight = order.OrderItems.Sum(x => x.Product.WeightInPounds);
if (method != null) {
result = new ShippingMethod();
result.ID = method.ShippingMethodID;
result.Carrier = method.Carrier;
result.EstimatedDelivery = method.EstimatedDelivery;
result.RatePerPound = method.RatePerPound;
result.ServiceName = method.ServiceName;
result.Cost = method.BaseRate + (method.RatePerPound * orderWeight);
}
return result;
}
public ShotDataStore(DbContext context)
{
_sqlRepository = new SqlRepository<t_shot>(context);
_selector = shot =>
{
return new Shot
{
ShotId = shot.ShotId,
PrimaryScore = shot.PrimaryScore,
SecondaryScore = shot.SecondaryScore,
Ordinal = shot.ShotOrdinal,
ValueX = shot.ValueX,
ValueY = shot.ValueY,
SubtotalId = shot.SubtotalId
};
};
}
private static void Main()
{
var dataDir = new DirectoryInfo(@"C:\historicaldata");
var csvRepo = new CsvRepository(dataDir);
var sqlRepo = new SqlRepository(@"Data Source=.;Initial Catalog=HistoricalQuotes;Integrated Security=True");
string processedFilesDir = Path.Combine(@"C:\historicaldata", "processed");
if (!Directory.Exists(processedFilesDir))
{
Directory.CreateDirectory(processedFilesDir);
}
FileInfo[] files = dataDir.GetFiles();
foreach (FileInfo file in files)
{
string symbol = Path.GetFileNameWithoutExtension(file.Name);
Console.Write(symbol);
IEnumerable<Quote> quotes = csvRepo.Set<Quote>(new Query {Symbol = symbol});
var fromDate = new DateTime(2011, 1, 1);
var toDate = new DateTime(2011, 12, 31);
// we're only interested in 2011 data
sqlRepo.AddMany(quotes.Where(q => q.Timestamp >= fromDate && q.Timestamp <= toDate));
string processedFileName = Path.Combine(processedFilesDir, file.Name);
if (File.Exists(processedFileName))
{
Console.Write("...Error (symbol already processed)");
Console.WriteLine();
continue;
}
if (file.Exists)
{
file.MoveTo(processedFileName);
}
Console.Write("...Done");
Console.WriteLine();
}
}
public void InsertOrUpdateTest()
{
var conn = new SqlConnection(@"Data Source=(local)\SQLEXPRESS;Initial Catalog=Budget;Integrated Security=Yes;");
var rep = new SqlRepository(conn);
var list = new List<DebitEntry>
{
new DebitEntry { LogTime = new DateTime(2015,1,1), Amount = 50.05m, Description = "Bla bla" }
, new DebitEntry { LogTime = new DateTime(2015,1,2), Amount = 150.05m, Description = "11 11 11" }
};
int userId = -1;
try
{
// Create a test user
userId = rep.InsertUser(new User { Name = "Test", Email = "*****@*****.**" });
var count = rep.CountDebitEntries(userId);
Assert.AreEqual(count, 0, "There are unexpected DebitEntry records after creating a new user");
// Insert a banch of debit entries
count = rep.BatchInsertOrUpdate(userId, list, true);
Assert.AreEqual(count, list.Count, "Number of inserted records is different from the amount to be inserted");
count = rep.CountDebitEntries(userId);
Assert.AreEqual(count, 2, "Total number of records is incorrect");
// Insert/Update a slightly modified list
list[1].Description = "11 11 22";
count = rep.BatchInsertOrUpdate(userId, list, false);
Assert.AreEqual(count, 1, "Number of inserted records is different from the amount to be inserted");
count = rep.BatchInsertOrUpdate(userId, list, true);
Assert.AreEqual(count, list.Count, "Number of inserted records is different from the amount to be inserted");
count = rep.CountDebitEntries(userId);
Assert.AreEqual(count, 3, "Total number of records is incorrect");
}
finally
{
rep.DeleteUser(userId);
}
}
private MinionContext InitializeContext()
{
// lazy static constructor for the DB will not get executed until this point, out of the FinishedLoading
// allowing the application to respond as quick as it can.
var minionContext = new MinionContext(DB.Main, new ObservableDomainEventBus());
var minionRepo = new SqlRepository<MinionContract>(DB.Main);
var allMinions = minionRepo.GetAll();
if (!allMinions.Any())
{
// bootstrap us some
var cmd = minionContext.NewCommandExecutor<MinionAggregate>();
cmd.Execute(new ChangeNameCommand {AggregateId = MinionId.NewId(), Name = "Minion 1" });
cmd.Execute(new ChangeNameCommand {AggregateId = MinionId.NewId(), Name = "Minion 2" });
cmd.Execute(new ChangeNameCommand {AggregateId = MinionId.NewId(), Name = "Minion 3" });
}
return minionContext;
}
public SqlUnitOfWork(DbContext context)
{
_dbcontext = context;
StudentMasters = new SqlRepository<StudentMaster>(context);
AcademicYears = new AcademicYearRepository(context);
AcademicTerms = new SqlRepository<AcademicTerm>(context);
Students = new StudentRepository(context);
ClassLabels = new SqlRepository<ClassLabel>(context);
Classes = new SqlRepository<Class>(context);
Subjects = new SqlRepository<Subject>(context);
Activities = new SqlRepository<Activity>(context);
DescriptiveIndicators = new SqlRepository<DescriptiveIndicator>(context);
Exams = new SqlRepository<Exam>(context);
AssessmentSchemas = new SqlRepository<AssessmentSchema>(context);
ExamResults = new SqlRepository<ExamResult>(context);
ActivityGrades = new SqlRepository<ActivityGrade>(context);
ScholasticSections = new SqlRepository<ScholasticSection>(context);
Houses = new SqlRepository<House>(context);
ExamGradingSchemas = new SqlRepository<ExamGradingSchema>(context);
ActivityGradingSchemas = new SqlRepository<ActivityGradingSchema>(context);
Attendances = new SqlRepository<Attendance>(context);
SelfAwarenesses = new SqlRepository<SelfAwareness>(context);
HealthInformations = new SqlRepository<HealthInformation>(context);
TeacherClassSubjectMaps = new SqlRepository<TeacherClassSubjectMap>(context);
Teachers = new SqlRepository<Teacher>(context);
ClassTeachers = new SqlRepository<ClassTeacher>(context);
ActivityResults = new SqlRepository<ActivityResult>(context);
Minorities = new SqlRepository<Minority>(context);
Categories = new SqlRepository<Category>(context);
StudentScores = new SqlRepository<StudentScore>(context);
StudentAssignments = new SqlRepository<StudentAssignment>(context);
SmsReports = new SqlRepository<SmsReport>(context);
TeacherUploads = new SqlRepository<TeacherUpload>(context);
Settings = new SqlRepository<Settings>(context);
Menus = new SqlRepository<Menu>(context);
StudentAttendances = new SqlRepository<StudentAttendances>(context);
ExamSections = new SqlRepository<ExamSection>(context);
ExamSectionResults = new SqlRepository<ExamSectionResult>(context);
}
public string ReceiveMessages(string chatRoomId, string userId)
{
IRepository<Message> messagesRepository = new SqlRepository<Message>(_dataContext);
IRepository<User> userRepository = new SqlRepository<User>(_dataContext);
string str = "";
var user = userRepository.FindOne(u => u.Id == Convert.ToInt16(userId));
List<Message> messages =
messagesRepository.FindAll(
m => m.Date > user.TimeLogIn - new TimeSpan(0, 1, 0) && m.RoomId == Convert.ToInt16(chatRoomId)).
ToList();
for (int i = 0; i < messages.Count(); i++)
{
var userName = userRepository.FindOne(u => u.Id == messages[i].UserId);
str += string.Format("{0}:{1}:{2} <{3}>: {4} \n\r", messages[i].Date.Hour, messages[i].Date.Minute,messages[i].Date.Second, userName.Name, messages[i].Text);
}
return str;
}
public static void Intialize(SqlRepository Repository)
{
Snapshot SnapshotA = new Snapshot(){
Name = "SnapshotA",
Active = true
};
SnapshotA.Activate(Repository);
Snapshot SnapshotB = new Snapshot()
{
Name = "SnapshotB",
Active = false
};
using(TransactionScope Scope = new TransactionScope())
{
SnapshotA.Track(Repository);
SnapshotB.Track(Repository);
Scope.Complete();
}
}
static void Main(string[] args)
{
var account = Radio7.ConfigReader.ConfigFactory.Instance.Resolve<AccountRepository>();
var setttings = Radio7.ConfigReader.ConfigFactory.Instance.Resolve<Settings>();
var logger = new ConsoleLogger();
var branchRepository = new BranchRepository(account, logger);
var branches = branchRepository.Get();
var commitRepository = new CommitRepository(account, logger);
var commits = commitRepository.Get(setttings.BranchName);
var prRepository = new PullRequestRepository(account, logger);
var pullRequests = prRepository.Get();
var sql = new SqlRepository(setttings.ConnectionString);
sql.LoadTable(branches);
sql.LoadTable(commits);
sql.LoadTable(pullRequests);
}
public SqlDictionaryForm(SqlRepository repository, string filePath)
{
InitializeComponent();
_currentSource = repository;
_currentFilePath = filePath;
}
/* DebitEntry[] entries =
{
new DebitEntry { ID=1, LogTime = new DateTime(2015,1,1), Amount = 50.05m, Description = "Bla bla" }
, new DebitEntry { ID=2, LogTime = new DateTime(2015,1,2), Amount = 150.05m, Description = "11 11 11" }
};*/
public DebitsController(string conn)
{
var sqlConn = new SqlConnection(conn);
repository = new SqlRepository(sqlConn);
}
public IEnumerable <Product> GetAll()
{
SqlRepository <Product> rep = new SqlRepository <Product>(new SqlServerDefaultContext());
return(rep.GetAll());
}
public AvisoSPService()
{
sqlRepository = new SqlRepository();
}
public SkuViewerService()
{
_repo = new SqlRepository();
}
public IEnumerable <T> GetAll <T>() where T : IOrmGenerated
{
using (var rep = new SqlRepository(_Configuration, _Logger))
return(rep.GetAll <T>() ?? new List <T>());
}
public async Task <TradingResult> ExecuteAsync(BitstampExchange bitstampExchange)
{
// get the latest ticker
var latestTicker = bitstampExchange.TickerHistory24H.OrderByDescending(t => t.Timestamp).Take(1).First();
// if the latest ticker is older than 30s then return
if (latestTicker.Timestamp < DateTime.Now.AddSeconds(-30))
{
return new TradingResult {
Timestamp = DateTime.Now, Message = "Warning: latest ticker is older then 30s"
}
}
;
// calculate the ticker average of the last x minutes (x = _averagePeriodInMinutes)
var tickerOfLastXMinutes = bitstampExchange.TickerHistory24H.Where(t => t.Timestamp > DateTime.Now.AddMinutes(-_averagePeriodInMinutes));
var tickerAverage = tickerOfLastXMinutes.Average(t => t.Last);
// todo: had to declare these variables outside the if statement, otherwise null execption on linq queries. Not sure why exactly
decimal sellPrice;
DateTime tickerTimestampMinus180Days;
// is the current price lower than the average minus x percent?
if (latestTicker.Last < tickerAverage * (1 - _averageBuyThresholdInPercents / 100))
{
// don't buy bitcoins if there was already a buy order in the last x minutes
if (bitstampExchange.LastBuyTimestamp > DateTime.Now.AddMinutes(-_pauseAfterBuyInMinutes))
{
return new TradingResult {
Timestamp = DateTime.Now, Message = "Bitcoins not bought, last buy was from " + bitstampExchange.LastBuyTimestamp
}
}
;
// don't buy bitcoins if there is already another sell order within range (+- 5%)
var sellOrderRangeInPercents = decimal.Parse(ConfigurationManager.AppSettings["SellOrderRangeInPercents"]);
sellPrice = latestTicker.Last * (1 + sellOrderRangeInPercents / 100);
var sellOrderExist = bitstampExchange.OpenOrders.Any(o => o.Type == BitstampOrderType.Sell && o.Price > sellPrice * 0.95M && o.Price < sellPrice * 1.05M);
if (sellOrderExist)
{
return(new TradingResult {
Timestamp = DateTime.Now, Message = "Bitcoins not bought, already an order in sell range"
});
}
// get the minimum and maximums from the last x days
var minMaxAveragePeriodInDays = int.Parse(ConfigurationManager.AppSettings["MinMaxAveragePeriodInDays"]);
tickerTimestampMinus180Days = latestTicker.Timestamp.AddDays(-minMaxAveragePeriodInDays);
var minMaxLogDb = new SqlRepository <MinMaxLog>(new BitstampTraderEntities()).Where(l => l.Day > tickerTimestampMinus180Days).ToList();
var min180DayDb = latestTicker.Last;
var max180DayDb = latestTicker.Last;
if (minMaxLogDb.Count > 0)
{
min180DayDb = minMaxLogDb.OrderBy(l => l.Minimum).First().Minimum;
max180DayDb = minMaxLogDb.OrderByDescending(l => l.Maximum).First().Maximum;
}
//calculate amount to buy
var relativePercentage = TradeHelpers.CalculateRelativePercentage(min180DayDb, max180DayDb, latestTicker.Last);
var maxUsdAmountToBuy = TradeHelpers.CalculateMaxUsdAmountToBuy(bitstampExchange.AccountBalance);
var btcAmountToBuy = TradeHelpers.CalculateBtcAmountToBuy(maxUsdAmountToBuy, 5M, relativePercentage, latestTicker);
// buy bitcoins
await bitstampExchange.BuyLimitOrderAsync(BitstampExchange.BitstampTickerCode.BtcUsd, Math.Round(btcAmountToBuy, 8), Math.Round(latestTicker.Last, 2));
}
return(new TradingResult {
BuyThreshold = (tickerAverage * (1 - _averageBuyThresholdInPercents / 100)).ToString(CultureInfo.InvariantCulture)
});
}
}
}
public void SaveOrder(Order o)
{
SqlRepository <Order> rep = new SqlRepository <Order>(new SqlServerDefaultContext());
rep.Insert(o);
}
public ReadModelBuilderQueue(SQLiteConnection connection)
{
this.repository = new SqlRepository<ReadModelWorkItem>(connection);
connection.CreateTable<ReadModelWorkItem>();
}
public SqlSnapshotRepository(SQLiteConnection connection)
{
//var repo = new SqlRepository<T>(connection);
//this.repository = new SyncRepository<T>(repo);
this.repository = new SqlRepository <T>(connection);
}
public CreateSchema(SqlRepository sqlRepository)
{
_sqlRepository = sqlRepository;
}
public static void Setup(TestContext context)
{
repository = new SqlRepository();
}
public ReadModelBuilderQueue(IUnitOfWorkScope scope)
{
var connection = scope.GetRegisteredObject<SQLiteConnection>();
this.repository = new SqlRepository<ReadModelWorkItem>(connection);
this.repository.Connection.CreateTable<ReadModelWorkItem>();
}
public static void Run()
{
var run = Program.Run.Nested;
var writeToConsole = false;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var repo = new SqlRepository(new SqlStore(Program.ConnectionString));
switch (run)
{
case Program.Run.Simple:
var pocos = DataFactory.Pocos(10000);
if (writeToConsole)
{
Console.WriteLine("##########POCOS##########");
Console.WriteLine(JsonConvert.SerializeObject(pocos, Formatting.Indented));
}
repo.Save(pocos);
break;
case Program.Run.SimpleNamedCollections:
var first = DataFactory.Pocos(100);
var second = DataFactory.Pocos(100);
if (writeToConsole)
{
Console.WriteLine("##########FIRST##########");
Console.WriteLine(JsonConvert.SerializeObject(first, Formatting.Indented));
Console.WriteLine("##########SECOND##########");
Console.WriteLine(JsonConvert.SerializeObject(second, Formatting.Indented));
}
//you can pass in a name for the collection, so you can create different tables with the same model
repo.Save(first, "FirstCollection");
repo.Save(second, "SecondCollection");
break;
case Program.Run.Nested:
var nested = DataFactory.NestedPocos(1000);
if (writeToConsole)
{
Console.WriteLine("##########NESTED##########");
Console.WriteLine(JsonConvert.SerializeObject(nested, Formatting.Indented));
}
repo.Save(nested, new FieldSelectorCollection <NestedPoco>()
{
new FieldSelector <NestedPoco, NestedPoco>(x => x),
new FieldSelector <NestedPoco, IEnumerable <Poco>, int>(
x => x.Pocos,
x => x.Id,
"NestedPocoId"
)
});
break;
case Program.Run.NestedNamedCollections:
var firstNested = DataFactory.NestedPocos(100);
var secondNested = DataFactory.NestedPocos(100);
if (writeToConsole)
{
Console.WriteLine("##########FIRSTNESTED##########");
Console.WriteLine(JsonConvert.SerializeObject(firstNested, Formatting.Indented));
Console.WriteLine("##########SECONDNESTED##########");
Console.WriteLine(JsonConvert.SerializeObject(secondNested, Formatting.Indented));
}
//when creating datasets you can also pass in collection names
repo.Save(firstNested, new FieldSelectorCollection <NestedPoco>()
{
new FieldSelector <NestedPoco, NestedPoco>(x => x, "FirstNestedCollection"),
new FieldSelector <NestedPoco, IEnumerable <Poco>, int>(
x => x.Pocos,
"FirstSubCollection",
x => x.Id,
"NestedPocoId"
)
});
//you can even pass in a function to return the name
repo.Save(secondNested, new FieldSelectorCollection <NestedPoco>()
{
new FieldSelector <NestedPoco, NestedPoco>(x => x, () => "SecondNestedCollection"),
new FieldSelector <NestedPoco, IEnumerable <Poco>, int>(
x => x.Pocos,
() => "SecondSubCollection",
x => x.Id,
"NestedPocoId"
)
});
break;
case Program.Run.DeeplyNested:
var deeplyNested = DataFactory.DeeplyNestedPocos(100).ToList();
if (writeToConsole)
{
Console.WriteLine("##########DEEPLYNESTED##########");
Console.WriteLine(JsonConvert.SerializeObject(deeplyNested, Formatting.Indented));
}
repo.Save(
deeplyNested.AsEnumerable(),
new FieldSelectorCollection <DeeplyNestedPoco>()
{
new FieldSelector <DeeplyNestedPoco, DeeplyNestedPoco>(x => x),
new FieldSelector <DeeplyNestedPoco, IEnumerable <NestedPoco>, int>(
x => x.NestedPocos,
x => x.Id,
"DeeplyNestedPocoId"
)
});
//NOTE this will enumerate twice; look at Run.DeeplyNestedExtended for a better example
repo.Save(
deeplyNested.SelectMany(x => x.NestedPocos),
new FieldSelectorCollection <NestedPoco>()
{
new FieldSelector <NestedPoco, IEnumerable <Poco>, int>(
x => x.Pocos,
x => x.Id,
"NestedPocoId"
)
});
break;
case Program.Run.DeeplyNestedExtended:
var deeplyNestedExtended = DataFactory.DeeplyNestedPocos(100).ToList();
if (writeToConsole)
{
Console.WriteLine("##########DEEPLYNESTED##########");
Console.WriteLine(JsonConvert.SerializeObject(deeplyNestedExtended, Formatting.Indented));
}
repo.Save(
deeplyNestedExtended.AsEnumerable(),
new FieldSelectorCollection <DeeplyNestedPoco>()
{
new FieldSelector <DeeplyNestedPoco, DeeplyNestedPoco>(x => x),
new FieldSelector <DeeplyNestedPoco, IEnumerable <NestedPoco>, int>(
x => x.NestedPocos,
x => x.Id,
"DeeplyNestedPocoId"
),
new FieldSelector <DeeplyNestedPoco, IEnumerable <Poco>, NestedPoco, int>(
x => x.NestedPocos
.Select(n => new ForeignKeyModelPair <NestedPoco, IEnumerable <Poco> >(n, n.Pocos)),
x => x.Id
)
});
break;
case Program.Run.Complex:
var mapper = Program.InitMapper();
var complex = DataFactory.ComplexPocos(1000);
if (writeToConsole)
{
Console.WriteLine("##########COMPLEX##########");
Console.WriteLine(JsonConvert.SerializeObject(complex, Formatting.Indented));
}
repo.Save(
complex,
new FieldSelectorCollection <ComplexPoco>()
{
new FieldSelector <ComplexPoco, Poco, int>(
x => x.InnerPoco,
x => x.Id,
"ComplexPocoId"
),
new FieldSelector <ComplexPoco, IDictionary <string, string>, int>(
x => x.SimpleDictionary,
x => x.Id,
"ComplexPocoId"
),
new FieldSelector <ComplexPoco, IEnumerable <DictPoco>, int>(
x => x.ComplexDictionary.Select(
p => mapper.Map(p.Value, new DictPoco {
DictKey = p.Key
})
),
x => x.Id,
"ComplexPocoId"
),
//TODO: add possibilty to map enumerables of 'single value' objects without mapping
new FieldSelector <ComplexPoco, IEnumerable <SingleValue <string> >, int>(
x => x.SimpleCollection.Select(p => new SingleValue <string>(p)),
x => x.Id,
"ComplexPocoId"
),
new FieldSelector <ComplexPoco, IEnumerable <Poco>, int>(
x => x.ComplexCollection,
x => x.Id,
"ComplexPocoId"
)
}
);
break;
}
stopWatch.Stop();
Console.WriteLine($"All done in {stopWatch.ElapsedMilliseconds}ms. Press any key.");
Console.ReadKey(true);
}
private void OpenFile(object sender, EventArgs e)
{
string filePath = string.Empty;
using (var openFileDialog = new OpenFileDialog())
{
openFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
openFileDialog.Filter = string.Format("{0} (*.{1})|*.{1}|All Files (*.*)|*.*",
"xml files", "xml");
if (openFileDialog.ShowDialog(this) == DialogResult.OK)
{
filePath = openFileDialog.FileName;
}
}
if (filePath.IsNullOrWhiteSpace())
{
return;
}
foreach (var child in MdiChildren)
{
if (child is IStandardActionForm && ((IStandardActionForm)child).CurrentFilePath.Trim().ToLower()
== filePath.Trim().ToLower())
{
child.Activate();
return;
}
}
Form childForm = null;
try
{
var result = new ApplicationRoleSchemaList();
result.LoadXmlFile(filePath);
childForm = new ApplicationRoleSchemaListForm(result, filePath);
}
catch (Exception) { }
if (childForm == null)
{
try
{
var result = new DbSchema();
result.LoadXmlFile(filePath);
childForm = new DbSchemaForm(filePath, result);
}
catch (Exception) { }
}
if (childForm == null)
{
try
{
var result = new SqlRepository();
result.LoadFile(filePath);
childForm = new SqlDictionaryForm(result, filePath);
}
catch (Exception) { }
}
if (childForm == null)
{
MessageBox.Show("File is not recognized as any Apskaita5 cofig file.", "",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
childForm.MdiParent = this;
childForm.Show();
}
public ApiController(SqlRepository sqlRepository)
{
_sqlRepository = sqlRepository;
}
public ProductManagerController()
{
context = new InMemoryRepository <Product>();
contextCategory = new InMemoryRepository <ProductCategory>();
}
public void Track(SqlRepository Repository)
{
string Query = "IF EXISTS(SELECT Name FROM " + _SnapshotTable + " WHERE Name = @Name) BEGIN " +
"UPDATE dbo.SnapshotManagement SET Active = @Active, StateChange = GETUTCDATE() " +
"WHERE Name = @Name END ELSE BEGIN " +
"INSERT INTO dbo.SnapshotManagement(Name, Active, StateChange) " +
"VALUES(@Name, @Active, GETUTCDATE()) END";
Dictionary<string, object> Parameters = new Dictionary<string, object>(){
{ "@Name", this.Name },
{ "@Active", this.Active }
};
Repository.Put(Query, Parameters, false);
}
