private static ScopeAggregate GetSimpleScope(out IDataAccessAdapter adapter)
{
adapter = new DataAccessAdapter();
var scope = LLBLGenDataScope.Create<LinqMetaData, FunctionMappingStore>(adapter);
var dep = new ScopeAggregate { DataScope = scope, Session = new object() };
return dep;
}
protected void Page_Load(object sender, EventArgs e)
{
if (_filterToUse != null)
{
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
TerritoryEntity instance = (TerritoryEntity)adapter.FetchNewEntity(new TerritoryEntityFactory(), new RelationPredicateBucket(_filterToUse));
if (instance != null)
{
laEmployeeTerritories.SetContainingEntity(instance, "EmployeeTerritories");
laEmployeesCollectionViaEmployeeTerritories.SetContainingEntity(instance, "EmployeesCollectionViaEmployeeTerritories");
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (_filterToUse != null)
{
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
CategoryEntity instance = (CategoryEntity)adapter.FetchNewEntity(new CategoryEntityFactory(), new RelationPredicateBucket(_filterToUse));
if (instance != null)
{
laProducts.SetContainingEntity(instance, "Products");
laSuppliersCollectionViaProducts.SetContainingEntity(instance, "SuppliersCollectionViaProducts");
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (_filterToUse != null)
{
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
CustomerDemographyEntity instance = (CustomerDemographyEntity)adapter.FetchNewEntity(new CustomerDemographyEntityFactory(), new RelationPredicateBucket(_filterToUse));
if (instance != null)
{
laCustomerCustomerDemo.SetContainingEntity(instance, "CustomerCustomerDemo");
laCustomersCollectionViaCustomerCustomerDemo.SetContainingEntity(instance, "CustomersCollectionViaCustomerCustomerDemo");
}
}
}
}
public async Task <IEnumerable <GovernorateEntity> > GetGovernoratesAsync()
{
IEnumerable <GovernorateEntity> governorates = null;
await Task.Run(async() =>
{
using (var adapter = new DataAccessAdapter())
{
var metaData = new LinqMetaData(adapter);
adapter.CloseConnection();
governorates = await metaData.Governorate.ToListAsync();
}
});
return(governorates);
}
/// <summary>
/// Marks the thread as done.
/// </summary>
/// <param name="threadId">Thread ID.</param>
/// <returns></returns>
public static async Task <bool> MarkThreadAsDoneAsync(int threadId)
{
var thread = await ThreadGuiHelper.GetThreadAsync(threadId);
if (thread == null)
{
// not found
return(false);
}
var containingSupportQueue = await SupportQueueGuiHelper.GetQueueOfThreadAsync(threadId);
thread.MarkedAsDone = true;
using (var adapter = new DataAccessAdapter())
{
// if the thread is in a support queue, the thread has to be removed from that queue. This is a multi-entity action and therefore we've to start a
// transaction if that's the case. If not, we can use the easy route and simply save the thread and be done with it.
if (containingSupportQueue == null)
{
// not in a queue, simply save the thread.
return(await adapter.SaveEntityAsync(thread).ConfigureAwait(false));
}
// in a queue, so remove from the queue and save the entity.
await adapter.StartTransactionAsync(IsolationLevel.ReadCommitted, "MarkThreadDone").ConfigureAwait(false);
try
{
// save the thread
var result = await adapter.SaveEntityAsync(thread).ConfigureAwait(false);
if (result)
{
// save succeeded, so remove from queue, pass the current adapter to the method so the action takes place inside this transaction.
await SupportQueueManager.RemoveThreadFromQueueAsync(threadId, adapter);
}
adapter.Commit();
return(true);
}
catch
{
// rollback transaction
adapter.Rollback();
throw;
}
}
}
/// <summary>
/// Determines whether the caller is allowed to load the entity instance specified.
/// </summary>
/// <param name="entity">The entity instance to be loaded</param>
/// <returns>true if the caller is allowed to load the entity specified, and false otherwise.</returns>
public override bool CanLoadEntity(IEntityCore entity)
{
// Check the type of the passed in entity
if (((EntityType)entity.LLBLGenProEntityTypeValue == EntityType.OrdersEntity))
{
// The following will execute a query for each Order, which is probably not the most efficient thing to do.
// This is just used for demo purposes and for authorization proof of concept.
// You may use prefetchPaths to fetch order details up front with the orders
// so the calculations can be done in memory, though this requires that the order detail entities are prefetched always.
// Also you can extend the OrderFactory to add a scalar field for the order total.
// See: http://weblogs.asp.net/fbouma/archive/2006/06/09/LLBLGen-Pro-v2.0-with-ASP.NET-2.0.aspx
// for details how to do that.
DataAccessAdapter adapter = new DataAccessAdapter();
object orderTotalObj = (object)adapter.GetScalar(OrderDetailsFields.OrderId,
(OrderDetailsFields.Quantity * OrderDetailsFields.UnitPrice), AggregateFunction.Sum,
(OrderDetailsFields.OrderId == ((OrdersEntity)entity).OrderId), new GroupByCollection(OrderDetailsFields.OrderId));
decimal orderTotal = 0;
if (orderTotalObj != null)
{
orderTotal = (decimal)orderTotalObj;
}
// Only Sales Managers can view Orders with a total sum >= 10,000.
if (orderTotal >= 10000)
{
if (IsUserInGroup("Sales") && IsUserInGroup("Manager"))
{
return(true);
}
else
{
return(false);
}
}
// Members of the following groups are allowed to load Orders of total sum < 10,000.
else if (IsUserInGroup("Sales") || IsUserInGroup("Marketing") || IsUserInGroup("Customer Relations"))
{
//Grant
return(true);
}
//Deny
return(false);
}
// Throw a Security Exception if a wrong entity type is used.
throw new ORMSecurityException("This Authorizer can't be used with an entity of type " + entity.LLBLGenProEntityName);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="suid">The Site UID of the requested entity.</param>
/// <returns>EntityCollection<ModuleInstanceEntity></returns>
public static EntityCollection <ModuleInstanceEntity> SelectBySiteUID(System.Int32 suid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleInstanceFields.SiteUID == suid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleInstanceEntity> modulesinstances = new EntityCollection <ModuleInstanceEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(modulesinstances, bucket);
return(modulesinstances);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="name">The name of the requested action entity.</param>
/// <returns>EntityCollection<ActionEntity></returns>
public static EntityCollection <ActionEntity> SelectByName(string name)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ActionFields.Name == name);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ActionEntity> actions = new EntityCollection <ActionEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(actions, bucket);
return(actions);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="isbuiltin">The IsBuiltin Flag of the requested entity.</param>
/// <returns>EntityCollection<ModuleSetEntity></returns>
public static EntityCollection <ModuleSetEntity> SelectByIsBuiltin(System.Boolean isbuiltin)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleSetFields.IsBuiltIn == isbuiltin);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleSetEntity> mse = new EntityCollection <ModuleSetEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(mse, bucket);
return(mse);
}
public Animal GetById(int id)
{
var connectionString = RuntimeConfiguration.GetConnectionString("AnimalContext");
using var adapter = new DataAccessAdapter(connectionString);
var metaData = new LinqMetaData(adapter);
return(metaData.Animal
.Where(animal => animal.Id == id)
.Select(animal => new Animal
{
Id = animal.Id,
Type = (AnimalType)animal.Type,
Name = animal.Name
}).SingleOrDefault());
}
public IList <Animal> GetByType(AnimalType type)
{
var connectionString = RuntimeConfiguration.GetConnectionString("AnimalContext");
using var adapter = new DataAccessAdapter(connectionString);
var metaData = new LinqMetaData(adapter);
return(metaData.Animal
.Where(animal => animal.Type == (int)type)
.Select(Animal => new Animal
{
Id = Animal.Id,
Type = (AnimalType)Animal.Type,
Name = Animal.Name
}).ToList());
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="instancesallowed">The Instances Allowed of the requested entity.</param>
/// <returns>EntityCollection<ModuleSetModuleEntity></returns>
public static EntityCollection <ModuleSetModuleEntity> SelectByInstancesAllowed(System.Int32 instancesallowed)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleSetModuleFields.InstancesAllowed == instancesallowed);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleSetModuleEntity> mse = new EntityCollection <ModuleSetModuleEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(mse, bucket);
return(mse);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="name">The Name of the requested entity.</param>
/// <returns>EntityCollection<ModuleSetEntity></returns>
public static EntityCollection <ModuleSetEntity> SelectByName(System.String name)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleSetFields.Name == name);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleSetEntity> mse = new EntityCollection <ModuleSetEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(mse, bucket);
return(mse);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="edittime">The Edit Time of the requested entity.</param>
/// <returns>EntityCollection<TemplateEntity></returns>
public static EntityCollection <TemplateEntity> SelectByEditTime(System.DateTime edittime)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(TemplateFields.EditTime == edittime);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <TemplateEntity> templates = new EntityCollection <TemplateEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(templates, bucket);
return(templates);
}
/// <summary>
/// Initializes the system, by running a stored procedure passing in the new admin password.
/// </summary>
/// <param name="newAdminPassword"></param>
/// <param name="emailAddress"></param>
/// <returns></returns>
public static async Task Initialize(string newAdminPassword, string emailAddress)
{
if (string.IsNullOrWhiteSpace(newAdminPassword))
{
return;
}
var passwordHashed = HnDGeneralUtils.HashPassword(newAdminPassword, performPreMD5Hashing: true);
using (var adapter = new DataAccessAdapter())
{
await ActionProcedures.InstallAsync(emailAddress, passwordHashed, adapter, CancellationToken.None);
CacheController.PurgeResultsets(CacheKeys.AnonymousUserQueryResultset);
}
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="isreadonly">The Is Read Only Flag of the requested entity.</param>
/// <returns>EntityCollection<ModuleInstanceEntity></returns>
public static EntityCollection <ModuleInstanceEntity> SelectByIsReadOnly(System.Boolean isreadonly)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleInstanceFields.IsReadOnly == isreadonly);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleInstanceEntity> modulesinstances = new EntityCollection <ModuleInstanceEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(modulesinstances, bucket);
return(modulesinstances);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="nametag">The Name Tag of the requested entity.</param>
/// <returns>EntityCollection<ModuleInstanceEntity></returns>
public static EntityCollection <ModuleInstanceEntity> SelectByNameTag(System.String nametag)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleInstanceFields.NameTag == nametag);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleInstanceEntity> modulesinstances = new EntityCollection <ModuleInstanceEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(modulesinstances, bucket);
return(modulesinstances);
}
/// <summary>
/// This function is used to insert a TemplateChunksEntity in the storage area.
/// </summary>
/// <param name="chunkid">Chunk ID</param>
/// <param name="templateguid">Template GUID</param>
/// <param name="ispreparsed">Is Preparsed Flag</param>
/// <param name="htmltext">HTML Text</param>
/// <param name="chunktype">Chunk Type</param>
/// <param name="prefix">Prefix</param>
/// <param name="tagname">TagName</param>
/// <param name="attributes">Attributes</param>
/// <returns>True on success, False on fail</returns>
public static bool Insert(int chunkid, Guid templateguid, bool ispreparsed, string htmltext, byte chunktype, string prefix, string tagname, string attributes)
{
TemplateChunksEntity templates = new TemplateChunksEntity();
templates.ChunkID = chunkid;
templates.TemplateGUID = templateguid;
templates.IsPreParsed = ispreparsed;
templates.HTMLText = htmltext;
templates.ChunkType = chunktype;
templates.Prefix = prefix;
templates.TagName = tagname;
templates.Attributes = attributes;
DataAccessAdapter ds = new DataAccessAdapter();
return(ds.SaveEntity(templates));
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="guid">The TemplateGUID of the requested entity.</param>
/// <returns>EntityCollection<TemplateChunksEntity></returns>
public static EntityCollection <TemplateChunksEntity> SelectByTemplateGUID(Guid guid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(TemplateChunksFields.TemplateGUID == guid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <TemplateChunksEntity> templatechunks = new EntityCollection <TemplateChunksEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(templatechunks, bucket);
return(templatechunks);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="siteuid">The SiteUID of the requested entity.</param>
/// <returns>EntityCollection<SiteSubSiteInfoEntity></returns>
public static EntityCollection <SiteSubSiteInfoEntity> SelectBySiteUID(int siteuid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(SiteSubSiteInfoFields.SiteUID == siteuid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <SiteSubSiteInfoEntity> sitenetinfo = new EntityCollection <SiteSubSiteInfoEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(sitenetinfo, bucket);
return(sitenetinfo);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="name">The Name of the requested entity.</param>
/// <returns>EntityCollection<SiteTypeEntity></returns>
public static EntityCollection <SiteTypeEntity> SelectByName(System.String name)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(SiteTypeFields.Name == name);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <SiteTypeEntity> sitestype = new EntityCollection <SiteTypeEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(sitestype, bucket);
return(sitestype);
}
/// <summary>
/// This function is used to update an SiteSubSiteInfoEntity.
/// </summary>
/// <param name="siteuid">Site Unique ID</param>
/// <param name="currentsubsitecount">The CurrentSubSiteCount of the requested entity.</param>
/// <param name="maxsubsites">The MaxSubSites of the requested entity.</param>
/// <returns>True on success, False on fail</returns>
public static bool Update(
int siteuid,
int currentsubsitecount,
int maxsubsites
)
{
SiteSubSiteInfoEntity siteinfos = new SiteSubSiteInfoEntity(siteuid);
siteinfos.IsNew = false;
siteinfos.SiteUID = siteuid;
siteinfos.CurrentSubSiteCount = currentsubsitecount;
siteinfos.MaxSubSites = maxsubsites;
DataAccessAdapter ds = new DataAccessAdapter();
return(ds.SaveEntity(siteinfos));
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="etguid">The Entity Type GUID of the requested entity.</param>
/// <returns>EntityCollection<GroupEntityPermissionEntity></returns>
public static EntityCollection <GroupEntityPermissionEntity> SelectByEntityTypeGUID(System.Guid etguid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(GroupEntityPermissionFields.EntityTypeGUID == etguid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <GroupEntityPermissionEntity> permissions = new EntityCollection <GroupEntityPermissionEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(permissions, bucket);
return(permissions);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="ouid">The Owner UID of the requested entity.</param>
/// <returns>EntityCollection<TemplateEntity></returns>
public static EntityCollection <TemplateEntity> SelectByOwnerUID(System.Int32 ouid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(TemplateFields.OwnerUID == ouid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <TemplateEntity> templates = new EntityCollection <TemplateEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(templates, bucket);
return(templates);
}
public void InsertBatch(IList <EmployeeEntity> employees)
{
if (employees == null || employees.Count == 0)
{
throw new ArgumentException($"{nameof(employees)} is null or empty.", nameof(employees));
}
using (var toInsert = new EntityCollection <EmployeeEntity>(employees))
{
using (var adapter = new DataAccessAdapter())
{
adapter.BatchSize = 100;
adapter.SaveEntityCollection(toInsert);
}
}
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="defguid">The Module Definition GUID of the requested entity.</param>
/// <returns>EntityCollection<ModuleSetModuleEntity></returns>
public static EntityCollection <ModuleSetModuleEntity> SelectByModuleDefinitionGUID(System.Guid defguid)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleSetModuleFields.ModuleDefinitionGUID == defguid);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleSetModuleEntity> mse = new EntityCollection <ModuleSetModuleEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(mse, bucket);
return(mse);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="flag">The Is Builtin Flag of the requested entity.</param>
/// <returns>EntityCollection<TemplateEntity></returns>
public static EntityCollection <TemplateEntity> SelectByIsBuiltin(System.Boolean flag)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(TemplateFields.IsBuiltin == flag);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <TemplateEntity> templates = new EntityCollection <TemplateEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(templates, bucket);
return(templates);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="allow">The Allow flag of the requested entity.</param>
/// <returns>EntityCollection<GroupEntityPermissionEntity></returns>
public static EntityCollection <GroupEntityPermissionEntity> SelectByAllow(System.Boolean allow)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(GroupEntityPermissionFields.Allow == allow);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <GroupEntityPermissionEntity> permissions = new EntityCollection <GroupEntityPermissionEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(permissions, bucket);
return(permissions);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="dt">The Edit Time of the requested entity.</param>
/// <returns>EntityCollection<ModuleInstanceEntity></returns>
public static EntityCollection <ModuleInstanceEntity> SelectByEditTime(System.DateTime dt)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(ModuleInstanceFields.EditTime == dt);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <ModuleInstanceEntity> modulesinstances = new EntityCollection <ModuleInstanceEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(modulesinstances, bucket);
return(modulesinstances);
}
/// <summary>
/// This function is used to query the data source for records.
/// </summary>
/// <param name="currentsubsitecount">The CurrentSubSiteCount of the requested entity.</param>
/// <returns>EntityCollection<SiteSubSiteInfoEntity></returns>
public static EntityCollection <SiteSubSiteInfoEntity> SelectByCurrentSubSiteCount(int currentsubsitecount)
{
PredicateExpression filter = new PredicateExpression();
filter.Add(SiteSubSiteInfoFields.CurrentSubSiteCount == currentsubsitecount);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(filter);
EntityCollection <SiteSubSiteInfoEntity> sitenetinfo = new EntityCollection <SiteSubSiteInfoEntity>();
DataAccessAdapter ds = new DataAccessAdapter();
ds.FetchEntityCollection(sitenetinfo, bucket);
return(sitenetinfo);
}
public void Should_perform_in_transaction_with_rollback()
{
var service = _container.Resolve<CustomerService>();
//THIS SHOULD HAPPEN IN A TRANSACTION
_facade.On(service).Invoke(a =>
{
a.SetNameToBrodie("CHOPS");
Assert.AreEqual("Brody", a.Query.Single(b => b.CustomerId == "CHOPS").CompanyName);
},false);
// transaction should have rolled back - iow, there should not be any more brody
var adapter = new DataAccessAdapter();
var md = new LinqMetaData(adapter);
Assert.AreNotEqual("Brody", md.Customer.Single(b => b.CustomerId == "CHOPS").CompanyName);
}
private void SetUpDatabaseConnection()
{
DatabaseConnectionString connectionString = new DatabaseConnectionString();
connectionString.ServerName = "SERVER14";
connectionString.DatabaseName = "Entrust";
connectionString.Username = "******";
connectionString.Password = "******";
connectionString.UseIntegratedAuthentication = false;
_adapter = new DataAccessAdapter(connectionString.ToString());
}
