/// <summary>
/// Creates a TransactionRepository Object
/// </summary>
/// <param name="dataAccess">Instanced <see cref="IDataAccess{T}" /> for <see cref="FinancialTransaction" /></param>
/// <param name="recurringDataAccess">
/// Instanced <see cref="IDataAccess{T}" /> for <see cref="RecurringTransaction" />
/// </param>
public TransactionRepository(IDataAccess<FinancialTransaction> dataAccess,
IDataAccess<RecurringTransaction> recurringDataAccess)
{
this.dataAccess = dataAccess;
this.recurringDataAccess = recurringDataAccess;
data = new ObservableCollection<FinancialTransaction>(this.dataAccess.LoadList());
}
public void BaseTestInitialize()
{
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.None,
Converters = new JsonConverter[] { new JsonKnownTypeConverter() }
};
var container = new UnityContainer().LoadConfiguration();
this.dataAccess = container.Resolve<IDataAccess>();
var formMetadata = this.dataAccess.GetProduct("1000");
var subpageMetadata = this.dataAccess.GetProduct("5000");
this.controlList = formMetadata.FormDefinition.Pages.AllControls;
this.subpageControlList = subpageMetadata.FormDefinition.Pages.AllControls;
this.validatorList = new RegexValidatorList
{
new RegexValidator
{
Id = "1",
Regex = "^((\\+\\d{1,3}[\\- ]?)??(\\(?\\d{1,4}\\)?[\\- ])?((?:\\d{0,5})\\d{3,4}[\\- ]?\\d{3,4}))?$",
Name = "Phone"
}
};
IEnumerable<Control> flatControls = this.controlList.Flatten();
this.defaultControlsAccess = new List<ControlAccess>(flatControls.Select(e => new ControlAccess(e.Id, AccessLevel.Write)));
}
public BoxEntry(IRecordView view, IDataAccess dataAccess)
{
if (view == null) throw new ArgumentNullException("view");
this.view = view;
this.dataAccess = dataAccess;
}
public SettingsViewModel(IDataAccess dataAccess)
{
this.dataAccess = dataAccess;
LightTheme = Settings.Default.LightTheme;
DBLocation = Settings.Default.DBLocation;
}
public void CreateProperlyFileInDb_Test()
{
// Arrange
ArrangeMocks();
_dataAccess = MockRepository.GenerateMock<IDataAccess>();
var service = new ScanningService(_lineProcessor, _dataAccess, _fileReader);
var actualCreatedFilePath = string.Empty;
_dataAccess.Expect(x => x.GetFile(Arg<string>.Is.Anything)).WhenCalled(x =>
{
actualCreatedFilePath = (string) x.Arguments[0];
})
.Return(GetTestFileEntity(_testPath));
_dataAccess.Expect(x => x.SaveWords(Arg<IEnumerable<string>>.Is.Anything)).Return(GetSaveWordsResult());
_dataAccess.Expect(x => x.AddWordEntries(Arg<List<WEntry>>.Is.Anything));
// Act
var actualResult = service.AddScanningFile(_testPath, _token);
actualResult.Wait(_token);
// Assert
_dataAccess.VerifyAllExpectations();
Assert.AreEqual(_testPath, actualCreatedFilePath);
}
public void Setup()
{
fakeDataAccess = Substitute.For<IDataAccess>();
fakeView = Substitute.For<IRecordView>();
target = new BoxEntry(fakeDataAccess);
target.View = fakeView;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserService"/> class.
/// </summary>
/// <param name="dataAccess">The data access.</param>
/// <exception cref="System.ArgumentNullException">dataAccess</exception>
public UserService(IDataAccess dataAccess)
{
if (dataAccess == null)
throw new ArgumentNullException ("dataAccess");
_dataAccess = dataAccess;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Stumps.Server.StumpsServerInstance"/> class.
/// </summary>
/// <param name="serverFactory">The factory used to initialize new server instances.</param>
/// <param name="serverId">The unique identifier of the Stumps server.</param>
/// <param name="dataAccess">The data access provider used by the instance.</param>
public StumpsServerInstance(IServerFactory serverFactory, string serverId, IDataAccess dataAccess)
{
if (serverFactory == null)
{
throw new ArgumentNullException("serverFactory");
}
_serverFactory = serverFactory;
this.ServerId = serverId;
_lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
_dataAccess = dataAccess;
// Setup the objects needed to keep track of Stumps.
_stumpList = new List<StumpContract>();
_stumpReference = new Dictionary<string, StumpContract>(StringComparer.OrdinalIgnoreCase);
// Setup the recordings maintained by the server instance.
this.Recordings = new Recordings();
// Initialize the server
InitializeServer();
// Initialize the Stumps
InitializeStumps();
}
public static User GetUser(IDataAccess dataAccess, int userId)
{
if(dataAccess == null)
throw new ArgumentNullException("dataAccess");
return dataAccess.Select<User>(DATA_ENTITY_USER, new Condition("UserId", userId)).FirstOrDefault();
}
public void SetupResult()
{
_mockery = new MockRepository();
_dataAccessMock = _mockery.CreateMock<DataAccess>();
_batch = new Batch(_dataAccessMock);
_batchHeaderDTO = _mockery.CreateMock<BatchHeaderDTO>();
}
public static void DisposeDataAccess()
{
if (_dataAccess == null) return;
_dataAccess.Dispose();
_dataAccess = null;
}
public TokenLogic(IDataAccess objDataAccess)
{
//primesc obiectul, nu e treaba TokenLogic ce dataAccess se foloseste
//unity are grija de dependency injection
_dataAccess = objDataAccess;
}
public MainViewModel()
{
data = new DataAccess.Data();
game = new Game(data, new List<string> { "Jessica", "Jack", "John", "Jane" }, Difficulty.Introductory);
notifier = new Notifier();
actionCardManager = game.ActionCardManager;
actionManager = game.ActionManager;
drawManager = game.DrawManager;
infectionManager = game.InfectionManager;
currentPlayer = new ObjectContext<Player>();
currentPlayer.Context = game.CurrentPlayer;
selectedPlayer = new ObjectContext<Player>();
messageContext = new ObjectContext<StringBuilder>();
messageContext.Context = new StringBuilder();
BoardViewModel = new BoardViewModel(game, currentPlayer, selectedPlayer, notifier);
MessageViewModel = new MessageViewModel(messageContext, game.NodeCounters);
foreach (Player player in game.Players)
{
player.Hand.DiscardManager.Block += DiscardManagerBlock;
player.Hand.DiscardManager.Release += DiscardManagerRelease;
}
drawManager.EpidemicDrawn += EpidemicDrawn;
game.GameOver += Game_GameOver;
game.GameWon += Game_GameWon;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Stumps.Server.Data.HttpRequestEntityReader"/> class.
/// </summary>
/// <param name="serverId">The unique identifier for the server.</param>
/// <param name="requestEntity">The request entity.</param>
/// <param name="dataAccess">The data access provider used by the instance.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="serverId"/> is <c>null</c>.
/// or
/// <paramref name="requestEntity"/> is <c>null</c>.
/// or
/// <paramref name="dataAccess"/> is <c>null</c>.
/// </exception>
public HttpRequestEntityReader(string serverId, HttpRequestEntity requestEntity, IDataAccess dataAccess)
{
if (string.IsNullOrWhiteSpace(serverId))
{
throw new ArgumentNullException("serverId");
}
if (requestEntity == null)
{
throw new ArgumentNullException("requestEntity");
}
if (dataAccess == null)
{
throw new ArgumentNullException("dataAccess");
}
_entity = requestEntity;
this.Headers = new HttpHeaders();
foreach (var pair in _entity.Headers)
{
this.Headers[pair.Name] = pair.Value;
}
_body = dataAccess.ServerReadResource(serverId, requestEntity.BodyResourceName) ?? new byte[0];
}
/// <summary>
/// Creates a AccountRepository Object
/// </summary>
/// <param name="dataAccess">Instanced account data Access</param>
public AccountRepository(IDataAccess<Account> dataAccess)
{
this.dataAccess = dataAccess;
Data = new ObservableCollection<Account>();
Load();
}
/// <summary>
/// Initializes a new instance of the <see cref="AttachmentManager"/> class.
/// </summary>
/// <param name="attachmentAccess">Provides access to application attachments.</param>
/// <param name="dataAccess">Provides access to the data layer.</param>
/// <param name="applicationManager">Manages applications.</param>
/// <param name="entitlementProvider">The entitlement provider.</param>
public AttachmentManager(IAttachmentAccess attachmentAccess, IDataAccess dataAccess, ApplicationManager applicationManager, IApplicationEntitlementProvider entitlementProvider)
: base(dataAccess)
{
this.attachmentAccess = attachmentAccess;
this.applicationManager = applicationManager;
this.entitlementProvider = entitlementProvider;
}
public ShiftRuleFactory(IDataAccess dataAccess)
{
LogSession.Main.EnterMethod(this, "ShiftRuleFactory");
try
{
/*--------- Your code goes here-------*/
this.DataAccess = dataAccess;
this.m_HardRulesRepository = new ShiftRuleCollection();
this.m_SoftRulesRepository = new ShiftRuleCollection();
CreateRulesInstances(ref m_HardRulesRepository, ref m_SoftRulesRepository);
foreach (var hardRule in this.m_HardRulesRepository)
{
LogSession.Main.LogObject("Hard Rules Repository item", hardRule);
}
foreach (var softRule in this.m_SoftRulesRepository)
{
LogSession.Main.LogObject("Soft Rules Repository item", softRule);
}
/*------------------------------------*/
}
catch (Exception ex)
{
LogSession.Main.LogException(ex);
throw ex;
}
finally
{
LogSession.Main.LeaveMethod(this, "ShiftRuleFactory");
}
}
public void Setup()
{
fakeDataAccess = Substitute.For<IDataAccess>();
fakeView = Substitute.For<ISearchView>();
target = new SearchPresenter(fakeDataAccess);
target.SearchView = fakeView;
}
/// <summary>
/// Initializes a new instance of the <see cref="SystemWorkflowManager" /> class.
/// </summary>
/// <param name="workflowService">Gateway into the workflow subsystem.</param>
/// <param name="formServiceGateway">Gateway into the forms subsystem.</param>
/// <param name="dataAccess">The data access.</param>
public SystemWorkflowManager(IWorkflowService workflowService, IFormServiceGateway formServiceGateway, IDataAccess dataAccess)
{
this.workflowService = workflowService;
this.formServiceGateway = formServiceGateway;
this.dataAccess = dataAccess;
this.productCache = new Dictionary<string, ProductVersionList>();
}
/// <summary>
/// A random static "Factory" method
/// </summary>
/// <param name="id">The value for the Id parameter.</param>
/// <param name="name">The value for the Name parameter.</param>
/// <param name="dataAccess">The data access.</param>
public static void RandomRepositoryMethod(Guid id, string name, IDataAccess dataAccess)
{
dataAccess.ExecuteNonQuery(
ConnectionString,
SomeRandomTableInsertSP,
DataAccess.CreateParameter("@Id", SqlDbType.UniqueIdentifier, id),
DataAccess.CreateParameter("@Name", SqlDbType.NVarChar, name));
}
public StudentRecordStatisForm()
{
InitializeComponent();
SystemConfig config = StaticCacheManager.GetConfig<SystemConfig>();
oraclDataAccess = new OracleDataHelper(config.TnsName, config.OraUser, config.OraPwd);
dtpEnd.Value = DateTime.Now.AddDays(1);
}
/// <summary>
/// Creates a TransactionRepository Object
/// </summary>
/// <param name="dataAccess">Instanced <see cref="IDataAccess{T}" /> for <see cref="FinancialTransaction" /></param>
/// <param name="recurringDataAccess">
/// Instanced <see cref="IDataAccess{T}" /> for <see cref="RecurringTransaction" />
/// </param>
public TransactionRepository(IDataAccess<FinancialTransaction> dataAccess,
IDataAccess<RecurringTransaction> recurringDataAccess)
{
this.dataAccess = dataAccess;
this.recurringDataAccess = recurringDataAccess;
Load();
}
/// <summary>
/// Constructor, sets the parameters
/// </summary>
/// <param name="loggerConfiguration">Logger Configuration Factory</param>
/// <param name="consoleAccess">Console Factory</param>
/// <param name="dataAccess">DB Data Factory</param>
/// <param name="fileAccess">File Factory</param>
public JobLogger(ILoggerConfiguration loggerConfiguration, IConsoleAccess consoleAccess, IDataAccess dataAccess, IFileAccess fileAccess)
{
this._dataAccess = dataAccess;
this._consoleAccess = consoleAccess;
this._fileAccess = fileAccess;
this._loggerConfiguration = loggerConfiguration;
}
public ScanningService(ILineProcessor lineProcessor, IDataAccess dataAccess, IFileReader fileReader)
{
_lineProcessor = lineProcessor;
_dataAccess = dataAccess;
_fileReader = fileReader;
Mapper.CreateMap<WordItem, WordModel>();
}
public BoxDetailsPresenter(IView view, IDataAccess dataAccess)
{
if (view == null) throw new Exception("view cannot be null");
this.view = view;
this.dataAccess = dataAccess;
box = new BoxEntry(view, dataAccess);
}
/// <summary>
/// Loads the module into the kernel.
/// </summary>
public override void Load()
{
this.Kernel.Bind<IDataAccess>().ToConstant<DataAccessProvider>(new DataAccessProvider(this._path));
this.DataAccessProvider = base.Kernel.Get<IDataAccess>();
this.CreateDatabaseMappings();
}
public AuthLogic(IDataAccess objDataAccess)
{
//primesc obiectul, nu e treaba UserLogic ce dataAccess se foloseste
//unity are grija de dependency injection
_dataAccess = objDataAccess;
TokenLogic = new TokenLogic(_dataAccess);
}
public BusinessLogic(IDataAccess _dataAccess)
{
FormLogic = new FormLogic(_dataAccess);
TokenLogic = new TokenLogic(_dataAccess);
UserLogic = new UserLogic(_dataAccess);
AuthLogic = new AuthLogic(_dataAccess);
CategoryLogic = new CategoryLogic(_dataAccess);
}
public PeraPortSapWsClient(IDataAccess dataAccess,INotification notification)
{
_dataAccess = dataAccess;
_notification = notification;
//ChildServiceParameters = new Dictionary<string, object>();
InitWebServiceClient();
DtoSet = new DtoSet();
}
public DBOperations()
{
if (System.Configuration.ConfigurationManager.ConnectionStrings["PlanetM"] != null)
DBAObj = new SQLDataAccess(System.Configuration.ConfigurationManager.ConnectionStrings["PlanetM"].ConnectionString);
else
DBAObj = new SQLDataAccess(PlanetM_Utility.Configuration.ReadConfig("ConnectionString"));
LogWrapper.LogInfo("DB Access Object created successfully.");
}
public Operations(IDataAccess da, ILogger log)
{
_da = da;
_log = log;
}
/// <summary>
/// Creates a new base repository class instance
/// </summary>
/// <param name="dataAccess">The data access allowing access to a data source</param>
public RepositoryBase(IDataAccess dataAccess)
{
this.data = dataAccess ?? throw new ArgumentNullException(nameof(dataAccess), "Please ensure we have a data access object from which we will interact with data");
}
public SelectCategoryWithQueryCountStep(IDataAccess <ICatchEmAllEntityContext> dataAccess, IViewModelEngine <ICatchEmAllEntityContext> viewModelEngine, IDashboard dashboard)
: base(dataAccess, viewModelEngine, dashboard)
{
this.dataAccess = dataAccess;
}
public GatewayScheduleSetup(IDataAccess dataAccess, CalculationView parent) : this(dataAccess)
{
this.parent = parent;
}
public SearchController(IYGOProDeckAccess yGOProDeckAccess, IDataAccess dataAccess)
{
_YGOProDeckAccess = yGOProDeckAccess;
_DataAccess = dataAccess;
}
public ItemData(IDataAccess dataAccess)
{
_dataAccess = dataAccess;
}
public HousingHandler(IDataAccess context)
{
this.Context = context;
this.UserHandler = new UserHandler(context);
}
public SalaryBusinessLogic(IDataAccess dta)
{
this.dta = dta;
}
public GetProductsQueryHandler(IDataAccess <ProductDTO> dataAcess) => this.dataAcess = dataAcess;
public GetGameListController(ILogger <GetGameListController> logger, DataSources dataSources)
{
_logger = logger;
_dataAccess = dataSources.DataAccess;
}
public UCObstetricsBaby()
{
InitializeComponent();
m_SqlHelper = DataAccessFactory.DefaultDataAccess;
}
public IndexModel(IDataAccess dataAccess)
{
_dataAccess = dataAccess;
}
public DeleteModel(IDataAccess data)
{
this.dataAccess = data;
}
public ServiceTwo(IDataAccess dataAccess, string name, ILogger <ServiceTwo> logger)
{
_dataAccess = dataAccess;
_name = name;
_logger = logger;
}
// the constructor passes in the two instances it will need for this ProcessData method, that will allow us pass up the chain the dependencies
public BusinessLogic(ILogger logger, IDataAccess dataAccess) // Constructor injection
{
_logger = logger; //take our parameters and we put into our class level variables (private variable)
_dataAccess = dataAccess;
}
public OrderData(IDataAccess dataAccess, ConnectionStringData connectionString)
{
_dataAccess = dataAccess;
_connectionString = connectionString;
}
public ApiControllerBase(IDataAccess <T> dataService, ILogger <ApiControllerBase <T> > logger)
{
_logger = logger;
_dataService = dataService;
}
public PostgreSqlObjectDataAccessProvider(Type runtimeType, IDataAccess dataAccess) : base(runtimeType, dataAccess)
{
Db = dataAccess;
}
public GatewayScheduleSetup(IDataAccess dataAccess) : this()
{
DataAccess = dataAccess;
yearsBox.Items.AddRange(DataAccess.GetColumnData <string>("SELECT YearName FROM YearsOfCalculations ORDER BY YearName DESC").ToArray());
yearsBox.Text = yearsBox.Items[0].ToString();
}
private void Inti()
{
m_SqlHelper = DataAccessFactory.DefaultDataAccess;
m_BizBus = BusFactory.GetBus();
m_Logger = m_BizBus.BuildUp <IYidanSoftLog>(new string[] { "报表设计器" });
}
public BusinessService(IDataAccess dataAccess)
{
_dataAccess = dataAccess;
}
public DashboardController(IDataAccess data = null, IConfig config = null)
{
_data = data ?? new DataAccess.DataAccess();
_config = config ?? new Config();
}
public ServiceOuvrages(IDataAccess factory) : base(factory)
{
}
protected DataExistContextBase(IDataAccess dataAccess, string name, ICondition criteria, IDataExistsOptions options = null) : base(dataAccess, name, DataAccessMethod.Exists, options ?? new DataExistsOptions())
{
this.Criteria = criteria;
this.Entity = DataContextUtility.GetEntity(name, dataAccess.Metadata);
}
public GetOrdersQueryHandler(IDataAccess <Common.Entities.Order> dataAcess) => this.dataAcess = dataAcess;
/// <summary>
/// 构造权限类
/// </summary>
public PermissionDal()
{
sql_helper = DataAccessFactory.DefaultDataAccess;
}
public StartScheduleStep(IDataAccess <ICatchEmAllEntityContext> dataAccess)
{
this.dataAccess = dataAccess;
}
public BetterBusinessLogic(ILogger logger, IDataAccess dataAccess)
{
_logger = logger;
_dataAccess = dataAccess;
}
public UserTabVM()
{
Name = "Users";
_dao = new SqliteDataAccess();
RefreshUsers();
}
public ServiceAdherents(IDataAccess factory) : base(factory)
{
}