public IEnumerable <ProductListDto> GetAllProducts()
{
var query = repo.Select(s => new ProductListDto
{
Id = s.Id,
Name = s.ProductName,
Price = s.UnitPrice,
Stock = s.UnitsInStock
});
return(query.ToList());
}
public async Task SelectOne()
{
Assert.Equal(
TestData.SponsorLevel01,
await Repository.Select(TestData.SponsorLevel01.Id)
);
}
private static void SelectTest()
{
IDbProvider provider = new SqlDataProvider();
provider.ConnectionString = $@"Integrated Security=SSPI;Persist Security Info=False;Initial Catalog={Settings.Instance.Database};Data Source={Settings.Instance.ServerName}";
var repository = new Repository <Customer>(provider);
string[] fields = { "Id", "Name" };
var name = new StringVariable("Name");
var value = new StringConstant("o");
var condition = new ComparativeOperator <string>(ComparativeOperatorType.Like, name, value);
List <DataProperty[]> result = repository.Select(condition, fields);
//List<Customer2> allCustomers = repository.LoadAll();
//List<Customer2> customersById = repository.LoadById(1,2,3);
//List<Customer2> customersByFilter = repository.LoadByFilter(condition);
if (result.Count != 0)
{
Console.WriteLine(result.Select(record => "{" + record.Select(p => p.Name + ": " + p.Value).Aggregate((p1, p2) => p1 + ", " + p2) + "}")
.Aggregate((r1, r2) => r1 + "\n" + r2));
}
else
{
Console.WriteLine("No record has been found for this condition!");
}
}
public void Update()
{
// Arrange
var todo = new TodoEntry()
{
OwnerId = 23, IsCompleted = false, Description = "Make a nice cake.", LastUpdated = new DateTime(2012, 12, 12)
};
// Act
Repository.SaveOrUpdate(todo);
todo.OwnerId++;
todo.IsCompleted = true;
todo.Description = "Eat cake.";
todo.LastUpdated = new DateTime(2010, 10, 10);
Repository.SaveOrUpdate(todo);
// Assert
var list = Repository.Select <TodoEntry>();
Assert.AreEqual(1, list.Count);
Assert.AreEqual(1, list[0].Id);
Assert.AreEqual(24, ((TodoEntry)list[0]).OwnerId);
Assert.AreEqual("Eat cake.", ((TodoEntry)list[0]).Description);
Assert.AreEqual(true, ((TodoEntry)list[0]).IsCompleted);
Assert.AreEqual(new DateTime(2010, 10, 10), ((TodoEntry)list[0]).LastUpdated);
}
public void Should_Insert_Entities()
{
var options = DatabaseOptions <FakeDbContext>();
var fakeEntities = new FakeEntities();
fakeEntities.ForEach(entity => entity.FakeChildEntities = null);
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Insert(fakeEntities);
var saveCount = repository.SaveChanges();
Assert.True(result.Count() > 0);
Assert.All(result, prop => Assert.True(prop.Id > 0));
Assert.Equal(fakeEntities.Count, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
var entryDateTime = result.First().CreatedTime;
Assert.Equal(fakeEntities.Count, result.Count());
Assert.All(result, prop => Assert.True(prop.Id > 0));
Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.CreatedBy));
Assert.All(result, prop => Assert.Equal(entryDateTime, prop.CreatedTime, TimeSpan.FromMinutes(1)));
}
}
internal static void PrintConectedSample()
{
Repository repo = new Repository();
var cnt = repo.Select <GCrane>().Count();
Console.WriteLine("Toltal recod = " + cnt);
if (cnt <= 0)
{
CodeConsole.WriteLineColor("Not read data", ConsoleColor.Black, ConsoleColor.Red);
}
else
{
CodeConsole.WriteLineColor("Read any data for sample", ConsoleColor.Black, ConsoleColor.Green);
}
var t1 = repo.QueryableSelect <GCrane>(x => x.Id == 1).First();
var t2 = repo.QueryableSelect <GCrane>(x => x.Id == 2).First();
t1.InitX++;
t2.InitY++;
repo.SaveChanges();
CodeConsole.WriteLineColor("t1.InitX = " + t1.InitX, ConsoleColor.Black, ConsoleColor.Green);
CodeConsole.WriteLineColor("t2.InitY = " + t2.InitY, ConsoleColor.Black, ConsoleColor.Green);
}
public async Task Should_Select_Entity_With_Primary_Key_Async()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
var entityToSearch = fakeEntities[2];
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
entityToSearch = repository.Select(prop => prop.EntityCode == entityToSearch.EntityCode).Single();
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = await repository.SelectAsync(entityToSearch.Id);
Assert.NotNull(result);
Assert.True(result.Id > 0);
Assert.Contains(fakeEntities, prop => prop.EntityCode == result.EntityCode);
Assert.Contains(fakeEntities, prop => prop.EntityName == result.EntityName);
}
}
public void Should_Insert_Entity()
{
var options = DatabaseOptions <FakeDbContext>();
var fakeEntity = new FakeEntities()[0];
fakeEntity.FakeChildEntities = null;
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Insert(fakeEntity);
var saveCount = repository.SaveChanges();
Assert.True(result.Id > 0);
Assert.Equal(1, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select(prop => prop.EntityCode == fakeEntity.EntityCode);
Assert.Single(result);
Assert.True(result.First().Id > 0);
Assert.True(result.First().EntityCode == fakeEntity.EntityCode);
Assert.True(result.First().EntityName == fakeEntity.EntityName);
Assert.Equal(Principal.Identity.Name, result.First().CreatedBy);
Assert.True(result.First().CreatedTime > DateTime.MinValue);
}
}
public void Using_TableNoTracking_Queryable_Cannot_Save_Changes()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
var fakeEntity = fakeEntities[0];
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var entityToUpdate = repository.TableNoTracking.Single(prop => prop.EntityCode == fakeEntity.EntityCode);
entityToUpdate.EntityName = "Modified";
var saveCount = repository.SaveChanges();
Assert.Equal(0, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
var singleResult = result.Single(prop => prop.EntityCode == fakeEntity.EntityCode);
Assert.Equal(fakeEntities.Count, result.Count());
Assert.NotEqual("Modified", singleResult.EntityName);
Assert.NotEqual(Principal.Identity.Name, singleResult.ModifiedBy);
Assert.False(singleResult.ModifiedTime > singleResult.CreatedTime);
}
}
public void CreateTwo()
{
// Arrange
var login1 = new Login()
{
Username = "******", Password = "******"
};
var login2 = new Login()
{
Username = "******", Password = "******"
};
// Act
Repository.SaveOrUpdate(login1);
Repository.SaveOrUpdate(login2);
// Assert
var list = Repository.Select <Login>();
Assert.AreEqual(2, list.Count);
Assert.AreEqual("username", ((Login)list[0]).Username);
Assert.AreEqual("password", ((Login)list[0]).Password);
Assert.AreEqual("login1", ((Login)list[1]).Username);
Assert.AreEqual("password2", ((Login)list[1]).Password);
}
private void loginButton_Click(object sender, EventArgs e)
{
Repository <LoginGateway, LoginUser> repository = new Repository <LoginGateway, LoginUser>();
LoginUser result = repository.Select(new LoginUser(userTextBox.Text, passwordTextBox.Text));
if (result == null)
{
MessageBox.Show("Connection error");
}
else if (result.Type == "admin")
{
AdminForm form = new AdminForm(result);
this.Hide();
form.Show();
}
else if (result.Type == "front")
{
FrontForm form = new FrontForm(result);
this.Hide();
form.Show();
}
else
{
MessageBox.Show("Error");
}
}
public ActionResult DataSource(DataManager dataManager)
{
IEnumerable data = new List <UserViewModel>();
int countAll = 0;
ZOperationResult operationResult = new ZOperationResult();
if (IsSearch())
{
try
{
SyncfusionGrid syncfusionGrid = new SyncfusionGrid(typeof(User), UnitOfWork.DBMS);
ArrayList args = new ArrayList();
string where = syncfusionGrid.ToLinqWhere(dataManager.Search, dataManager.Where, args);
string orderBy = syncfusionGrid.ToLinqOrderBy(dataManager.Sorted);
int take = (dataManager.Skip == 0 && dataManager.Take == 0) ? AppDefaults.SyncfusionRecordsBySearch : dataManager.Take; // Excel Filtering
data = ZViewHelper <UserViewModel, UserDTO, User> .ToViewList(Repository.Select(where, args.ToArray(), orderBy, dataManager.Skip, take));
if (dataManager.RequiresCounts)
{
countAll = Repository.Count(where, args.ToArray());
}
}
catch (Exception exception)
{
operationResult.ParseException(exception);
}
if (!operationResult.Ok)
{
throw new InvalidOperationException(operationResult.Text);
}
}
return(Json(JsonConvert.SerializeObject(new { result = data, count = countAll }), JsonRequestBehavior.AllowGet));
}
internal static UserDetails GetCurrentUser(HttpRequestMessage request)
{
if (!request.Headers.Contains("auth_token"))
{
return(UserDetails.Anonymous);
}
var authToken = Repository.Select <AuthToken>(Where.EqualStr("Token", request.Headers.GetValues("auth_token").FirstOrDefault()));
if (authToken.Count == 0)
{
return(UserDetails.Anonymous);
}
// (we don't have user profiles, so just grab their login name for "display name")
var login = Repository.Select <Login>(Where.EqualLong("Id", authToken.First().OwnerId));
if (login.Count == 0)
{
return(UserDetails.Anonymous);
}
return(new UserDetails()
{
DisplayName = login[0].Username, IsAuthenticated = true, UserId = login[0].Id
});
}
public void CreateTwo()
{
// Arrange
var authToken1 = new AuthToken()
{
OwnerId = 88, Token = "CheeseSandwich"
};
var authToken2 = new AuthToken()
{
OwnerId = 77, Token = "ChocolateCake"
};
// Act
Repository.SaveOrUpdate(authToken1);
Repository.SaveOrUpdate(authToken2);
// Assert
var list = Repository.Select <AuthToken>();
Assert.AreEqual(2, list.Count);
Assert.AreEqual(88, list[0].OwnerId);
Assert.AreEqual("CheeseSandwich", list[0].Token);
Assert.AreEqual(77, list[1].OwnerId);
Assert.AreEqual("ChocolateCake", list[1].Token);
}
public void Should_Delete_Entity_With_Entity_Object()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
var fakeEntity = fakeEntities[0];
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var entityToDelete = repository.Select(prop => prop.EntityCode == fakeEntity.EntityCode).Single();
repository.Delete(entityToDelete);
var saveCount = repository.SaveChanges();
Assert.Equal(1, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
var singleResult = result.Single(prop => prop.EntityCode == fakeEntity.EntityCode);
Assert.Equal(fakeEntities.Count, result.Count());
Assert.True(singleResult.IsDeleted);
Assert.True(singleResult.DeletedTime == singleResult.ModifiedTime);
Assert.True(singleResult.ModifiedTime > singleResult.CreatedTime);
Assert.Equal(Principal.Identity.Name, singleResult.ModifiedBy);
}
}
public void Should_Delete_Entities()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var entitiesToDelete = repository.Select();
repository.Delete(entitiesToDelete);
var saveCount = repository.SaveChanges();
Assert.Equal(entitiesToDelete.Count(), saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
Assert.Equal(fakeEntities.Count, result.Count());
Assert.All(result, prop => Assert.True(prop.IsDeleted));
Assert.All(result, prop => Assert.True(prop.DeletedTime == prop.ModifiedTime));
Assert.All(result, prop => Assert.True(prop.ModifiedTime > prop.CreatedTime));
Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.ModifiedBy));
}
}
public void Should_Update_Entities()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var entitiesToUpdate = repository.Select().ToList();
entitiesToUpdate.ForEach(entity => entity.EntityName = "Modified");
var result = repository.Update(entitiesToUpdate);
var saveCount = repository.SaveChanges();
Assert.All(entitiesToUpdate, prop => Assert.True(prop.Id > 0));
Assert.Equal(entitiesToUpdate.Count, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
Assert.Equal(fakeEntities.Count, result.Count());
Assert.All(result, prop => Assert.Equal("Modified", prop.EntityName));
Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.ModifiedBy));
Assert.All(result, prop => Assert.True(prop.ModifiedTime > prop.CreatedTime));
}
}
public void Query_Tracking_Behavior_Default_To_Track_All()
{
var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext));
var fakeEntities = new FakeEntities();
var fakeEntity = fakeEntities[0];
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var entityToUpdate = repository.Select(prop => prop.EntityCode == fakeEntity.EntityCode).Single();
entityToUpdate.EntityName = "Modified";
var saveCount = repository.SaveChanges();
Assert.Equal(1, saveCount);
}
using (IDbContext context = new FakeDbContext(options))
{
var repository = new Repository <FakeEntity>(context);
var result = repository.Select();
var singleResult = result.Single(prop => prop.EntityCode == fakeEntity.EntityCode);
Assert.Equal(fakeEntities.Count, result.Count());
Assert.Equal("Modified", singleResult.EntityName);
Assert.Equal(Principal.Identity.Name, singleResult.ModifiedBy);
Assert.True(singleResult.ModifiedTime > singleResult.CreatedTime);
}
}
public Task <ApiResponse <IEnumerable <ProfessorDto> > > GetAllAsync()
{
return(ExecuteSafely(async() =>
{
var data = await Repository.Select(professor => Mapper.Map <ProfessorDto>(professor)).ToArrayAsync();
return (IEnumerable <ProfessorDto>)data;
}));
}
public Task <ApiResponse <IEnumerable <DirectoryDto> > > GetAllAsync()
{
return(ExecuteSafely(async() =>
{
var directories = await Repository.Select(u => Mapper.Map <DirectoryDto>(u)).ToArrayAsync();
return (IEnumerable <DirectoryDto>)directories;
}));
}
public async Task SelectSome_Exceptional()
{
Database.AddSqlException();
Assert.IsType <System.Data.SqlClient.SqlException>(
await Record.ExceptionAsync(() =>
Repository.Select(Enumerable.Range(1, 3))
)
);
}
public async Task SelectSome_NoneFound()
{
IEnumerable <Event> actual =
await Repository.Select(
Enumerable.Range(1, 5)
);
Assert.Empty(actual);
}
public async Task SelectAll_Exceptional()
{
Database.AddSqlException();
Assert.IsType <System.Data.SqlClient.SqlException>(
await Record.ExceptionAsync(() =>
Repository.Select()
)
);
}
public void PopulateComboBoxes()
{
List <Employee> employees = new Repository().GetAllEmployees();
foreach (var id in employees.Select(employee => employee.EmployeeID).ToList())
{
comboBoxReportsTo.Items.Add(id);
}
}
public async Task SelectAll()
{
IEnumerable <SponsorLevel> actual = await Repository.Select();
Assert.True(TestData.AllSponsorLevels.SequenceEqual(actual), $@"
Expected Json: {JsonConvert.SerializeObject( TestData.AllSponsorLevels, Formatting.Indented )}
Actual Json: {JsonConvert.SerializeObject( actual, Formatting.Indented )}");
}
public T Select(int id)
{
if (id == 0)
{
throw new ArgumentException("Id não pode ser 0.");
}
return(repository.Select(id));
}
public CommittedEventStream ReadFrom(System.Guid id, long minVersion, long maxVersion)
{
var storedEvents = new Repository<StoredEvent>(_session).All()
.Where(x => x.EventSourceId == id)
.Where(x => x.EventSequence >= minVersion)
.Where(x => x.EventSequence <= maxVersion)
.ToList().OrderBy(x => x.EventSequence);
return new CommittedEventStream(id, storedEvents.Select(ToComittedEvent));
}
public void RegisterChecker(string username)
{
string sqlQuery = "SELECT UsernameFROM Player WHERE username = '******'";
if (username != "")
{
repo.Select(sqlQuery);
}
}
public virtual T GetId(int id)
{
if (id == 0)
{
throw new ArgumentException("The id can't be zero.");
}
return(repository.Select(id));
}
// Selection into the Player table "For an account"
private void SelectAccount(string username, string password)
{
// logic completed for (playerID, username, password) Just incase it is needed just add (int playerID) to be the first parameter
// .................................................................................................................................
//string sqlQuery = "SELECT PlayerID, Username, Password FROM Player WHERE playerid = '" + playerID + "' username = '******' AND password = '******'";
string sqlQuery = "SELECT Username, Password FROM Player WHERE username = '******' AND password = '******'";
repo.Select(sqlQuery);
}
public async Task <OrganizationResult> UpdateBuyerOrganization(IOrganizationCustomer cu, OrganizationUpdateInput input)
{
_logger.LogInformation(GetLogMessage("Organization:{0}; input:{@input}"), cu.OrganizationId, input);
var org = Repository.Select(x => x.Id == cu.OrganizationId).First();
org.InjectFrom(input);
return(await Update(org, input));
}
/// <summary>
/// Returns the area by its Id.
/// </summary>
/// <param name="areaId">Area Id.</param>
/// <returns>A area by its Id.</returns>
public Area GetArea(string areaId)
{
Area ret = null;
Guid id = Infrastructure.Utilities.Input.GetGuid(areaId);
if (id != Guid.Empty)
{
using (Repository repo = new Repository())
ret = repo.Select<Area>(id);
}
return ret;
}
/// <summary>
/// Returns the sector by its Id.
/// </summary>
/// <param name="sectorId">Sector Id.</param>
/// <returns>A sector by its Id.</returns>
public Sector GetSector(string sectorId)
{
Sector ret = null;
Guid id = Infrastructure.Utilities.Input.GetGuid(sectorId);
if (id != Guid.Empty)
{
using (Repository repo = new Repository())
ret = repo.Select<Sector>(id);
}
return ret;
}
public Definition CategoryDefinition(string name, string description)
{
Definition category = _definitions.Value.SingleOrDefault(x => x.Name == name);
if (category == null)
{
var definitionTypes = new Repository<DefinitionType>(_sessionProvider);
var categoryType = (DefinitionType)EnumerableExtensions.First(definitionTypes.Select());
category = new Definition { Name = name, Description = description, DefinitionType = categoryType, };
}
category.Deleted = false;
return category;
}
/// <summary>
/// Returns all routes for a given sector.
/// </summary>
/// <param name="sectorId">Sector Id.</param>
/// <returns>All routes for a given sector.</returns>
public IEnumerable<Route> GetSectorRoutes(string sectorId)
{
Route r = null;
List<Route> ret = new List<Route>();
Guid id = Infrastructure.Utilities.Input.GetGuid(sectorId);
if (id != Guid.Empty)
{
using (Repository repo = new Repository())
{
using (System.Data.IDataReader reader = repo.Select(SqlBuilder.Select("Route", "[SectorId] = @id"), new Parameter("id", id)))
{
while (reader.Read())
{
r = Repository.Read<Route>(reader);
if (r != null && r.Id != Guid.Empty)
ret.Add(r);
}
}
}
}
if (ret.Any())
ret.Sort((x, y) => { return x.Order - y.Order; });
return ret;
}
public void CanAddNew()
{
var cn = Maker.CreateContent();
var repC = new Repository<Content>(Factory);
using (var t = Session.BeginTransaction())
{
repC.Add(cn);
t.Commit();
}
var c2 = repC.Select(c => c.Title == "Title").First();
Assert.IsNotNull(c2);
}
/// <summary>
/// Loads model by area Id.
/// </summary>
/// <param name="areaId">Area Id.</param>
/// <returns>View model.</returns>
public static AreaViewModel Load(Guid areaId)
{
Area area = null;
Route route = null;
Sector sector = null;
AreaViewModel ret = null;
SectorSummary summary = null;
HashSet<Guid> addedRoutes = null;
List<SectorSummary> summaries = null;
IDictionary<Guid, Tuple<Sector, IList<Route>>> sectors = null;
if (areaId != Guid.Empty)
{
ret = new AreaViewModel();
addedRoutes = new HashSet<Guid>();
summaries = new List<SectorSummary>();
sectors = new Dictionary<Guid, Tuple<Sector, IList<Route>>>();
using (Repository repo = new Repository())
{
using (System.Data.IDataReader reader = repo.Select(SqlBuilder.SelectAll("a.[Id] = @areaId"), new Infrastructure.Storage.Parameter("areaId", areaId)))
{
while (reader.Read())
{
if (area == null)
{
area = Infrastructure.Storage.Repository.Read<Area>(reader, "Area");
if (area != null)
area.CopyTo(ret);
}
sector = Infrastructure.Storage.Repository.Read<Sector>(reader, "Sector");
route = Infrastructure.Storage.Repository.Read<Route>(reader, "Route");
if (sector != null && sector.Id != Guid.Empty)
{
if (!sectors.ContainsKey(sector.Id))
sectors.Add(sector.Id, new Tuple<Sector, IList<Route>>(sector, new List<Route>()));
if (route != null && route.Id != Guid.Empty && !addedRoutes.Contains(route.Id))
{
sectors[sector.Id].Item2.Add(route);
addedRoutes.Add(route.Id);
}
}
}
}
}
foreach (Tuple<Sector, IList<Route>> s in sectors.Values)
{
summary = new SectorSummary(s.Item1);
summary.Routes = s.Item2.OrderBy(r => r.Order).ToList();
summaries.Add(summary);
}
ret.Sectors = summaries.OrderBy(s => s.Order).ToList();
}
return ret;
}
