public void Init(string testName)
{
TestName = testName;
QueryServiceMock queryService = new QueryServiceMock();
WoxContextServiceMock woxContextService = new WoxContextServiceMock(queryService);
SystemWebAppServiceMock systemService = new SystemWebAppServiceMock();
IDataAccessService dataAccessService = new DataAccessService(systemService);
IWebAppItemRepository webAppItemRepository = new WebAppItemRepository(dataAccessService);
IWebAppConfigurationRepository webAppConfigurationRepository = new WebAppConfigurationRepository(dataAccessService);
FileGeneratorServiceMock fileGeneratorService = new FileGeneratorServiceMock();
FileReaderServiceMock fileReaderService = new FileReaderServiceMock();
IHelperService helperService = new HelperService();
ApplicationInformationServiceMock applicationInformationService = new ApplicationInformationServiceMock();
IWebAppService webAppService = new WebAppService(dataAccessService, webAppItemRepository, webAppConfigurationRepository, systemService, fileGeneratorService, fileReaderService, helperService);
IWoxResultFinder woxWebAppResultFinder = new WebAppResultFinder(woxContextService, webAppService, helperService, applicationInformationService, systemService);
systemService.ApplicationDataPath = GetApplicationDataPath();
WoxContextService = woxContextService;
QueryService = queryService;
SystemService = systemService;
WebAppService = webAppService;
FileGeneratorService = fileGeneratorService;
FileReaderService = fileReaderService;
WoxWebAppResultFinder = woxWebAppResultFinder;
HelperService = helperService;
ApplicationInformationService = applicationInformationService;
WoxContextService.AddQueryFetcher("wap", WoxWebAppResultFinder);
}
public void ValidCatalogFileLocationTest()
{
//--Arrange
var inMemorySettings = new Dictionary <string, string> {
{ "DataLocation", _testCatalogFileName }
};
IConfiguration testConfiguration = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
DataAccessService dataAccessService = new DataAccessService(_logMock.Object, testConfiguration);
Hashtable expected = new Hashtable();
foreach (Product product in sampleValidProducts)
{
expected.Add(product.Name, (Product)product);
}
//--Act
Hashtable result = dataAccessService.GetProductCatalog();
//--Assert
Assert.AreEqual(expected.Count, result.Count);
foreach (DictionaryEntry expectedKV in expected)
{
result[expectedKV.Key].Should().BeEquivalentTo(expected[expectedKV.Key]);
}
}
public void UpdateTaskStatus(int taskId, int taskStatus)
{
var connectionString = Configuration.Instance.GetConnectionString("WriteConnectionString");
var da = new DataAccessService(connectionString);
var query = $"UPDATE PTASK SET S_PLTICKET_STATUS = {taskStatus} WHERE PTASKID = {taskId} ";
var result = da.ExecuteCommand(query);
}
public void Init()
{
DataAccessService.Init();
PrefixDefinitionRepository.Init();
UnitDefinitionRepository.Init();
var nullScalar = new ScalarFloat();
foreach (var prefixDefinition in PrefixDefinitionRepository.GetPrefixDefinitions())
{
try
{
UnitService.AddPrefix(prefixDefinition.Name, prefixDefinition.Symbol, "user", nullScalar.GetNewFromFloat(prefixDefinition.Factor) as ScalarFloat, prefixDefinition.Inverted);
}
catch
{
}
}
foreach (var unitDefinition in UnitDefinitionRepository.GetUnitDefinitions())
{
try
{
var unit = UnitService.Parse(unitDefinition.Definition);
UnitService.AddUnit(unit, unitDefinition.Name, unitDefinition.Symbol, "user");
}
catch
{
}
}
}
public HttpResponseMessage SaveProfile([FromBody] Result modelResult) //[FromBody]
{
DataAccessService objservice = new DataAccessService();
try
{
Logger.Info("SaveProfile Exception:" + modelResult.WWID + " Result Detail Count - " + Convert.ToString(modelResult.ResultDetail.Count()));
if (!String.IsNullOrEmpty(modelResult.FirstName) && !String.IsNullOrEmpty(modelResult.LastName))
{
var data = objservice.SaveResult(modelResult);
if (data)
{
return(Request.CreateResponse(HttpStatusCode.OK, "Saved Successfully", Configuration.Formatters.JsonFormatter));
}
else
{
return(Request.CreateResponse(HttpStatusCode.ExpectationFailed, "Exception Occured!", Configuration.Formatters.JsonFormatter));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "First Name and LastName is required.", Configuration.Formatters.JsonFormatter));
}
}
catch (Exception ex)
{
Logger.Info("SaveProfile Exception:" + ex);
return(Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, "Failed", ex));
}
}
public WorkspacerConfiguration GetConfiguration()
{
if (WorkspacerConfiguration == null)
{
WorkspacerConfiguration = new WorkspacerConfiguration {
Launcher = "\"%1\""
};
}
var items = DataAccessService
.GetQuery("select key, value from configuration;")
.Returning <ConfigurationItem>()
.Reading("key", (ConfigurationItem item, string data) => item.Key = data)
.Reading("value", (ConfigurationItem item, string data) => item.Value = data)
.Execute();
foreach (var item in items)
{
switch (item.Key)
{
case nameof(WorkspacerConfiguration.Launcher):
WorkspacerConfiguration.Launcher = item.Value;
break;
default:
break;
}
}
return(WorkspacerConfiguration);
}
public void UpgradeFromNewVersionWithManyData()
{
DataAccessService.Init();
CreateNewSchema();
DataAccessService.GetQuery("insert into webapp_item values (1, 'https://url1.dom/x1', 'keywords1', 'search1', 'mank');").Execute();
DataAccessService.GetQuery("insert into webapp_item values (2, 'https://url2.dom/x2', 'keywords2', 'search2', 'default');").Execute();
DataAccessService.GetQuery("insert into webapp_item values (3, 'https://url3.dom/x3', 'keywords3', 'search3', 'shon');").Execute();
WebAppItemRepository.Init();
EnsureSchema();
var items = GetWebAppItems();
Assert.AreEqual(3, items.Count());
Assert.AreEqual(1, items.First().Id);
Assert.AreEqual("https://url1.dom/x1", items.First().Url);
Assert.AreEqual("keywords1", items.First().Keywords);
Assert.AreEqual("mank", items.First().Profile);
Assert.AreEqual(2, items.ElementAt(1).Id);
Assert.AreEqual("https://url2.dom/x2", items.ElementAt(1).Url);
Assert.AreEqual("keywords2", items.ElementAt(1).Keywords);
Assert.AreEqual("default", items.ElementAt(1).Profile);
Assert.AreEqual(3, items.ElementAt(2).Id);
Assert.AreEqual("https://url3.dom/x3", items.ElementAt(2).Url);
Assert.AreEqual("keywords3", items.ElementAt(2).Keywords);
Assert.AreEqual("shon", items.ElementAt(2).Profile);
}
protected override async Task <bool> OnRequestAsync(string parameter)
{
bool success = false;
var newForecasts = new List <ForecastViewModel>();
try
{
var current = await DataAccessService.GetCurrentWeatherAsync(SearchLocation, true);
var forecasts = await DataAccessService.GetForecastAsync(SearchLocation, true);
foreach (var forecast in forecasts.Forecasts)
{
newForecasts.Add(ForecastViewModel.FromModel(forecast));
}
CurrentWeather = CurrentWeatherViewModel.FromModel(current);
UpdateCollection(Forecasts, newForecasts);
await SaveForecastsAsync();
await SaveCurrentWeatherAsync();
success = true;
}
catch
{
success = false;
}
return(success);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
DataAccessService dataService = new DataAccessService();
Dictionary <int, string> IdNames = dataService.GetEmployees();
return(IdNames[(int)value]);
}
public void SalesOrderCRUDTest()
{
var dataObject = DomainModelBuilder.CreateDataObject();
var domainModel = DomainModelBuilder.CreateDomainModel();
var dataObjectManager = new NSharding.DomainModel.Manager.DataObjectManager();
var domainModelManager = new NSharding.DomainModel.Manager.DomainModelManager();
try
{
dataObjectManager.DeleteDataObject(dataObject.ID);
dataObjectManager.SaveDataObject(dataObject);
domainModelManager.DeleteDomainModel(domainModel.ID);
domainModelManager.SaveDomainModel(domainModel);
var orders = OrderAssert.CreateOrders();
DataAccessService.GetInstance().Save(domainModel.ID, orders);
var dataTables = DataAccessService.GetInstance().GetData(domainModel.ID, orders.ID);
Assert.IsNotNull(dataTables);
}
finally
{
dataObjectManager.DeleteDataObject(dataObject.ID);
domainModelManager.DeleteDomainModel(domainModel.ID);
}
}
public void Init(string testName)
{
TestName = testName;
QueryServiceMock queryService = new QueryServiceMock();
WoxContextServiceMock woxContextService = new WoxContextServiceMock(queryService);
var constantProvider = new ConstantProvider <ScalarFloat, float>();
IUnitService <ScalarFloat, float> unitService = new UnitService <ScalarFloat, float>(constantProvider);
SystemServiceMock systemService = new SystemServiceMock();
IDataAccessConfigurationService dataAccessConfigurationService = new DataAccessConfigurationService(systemService);
IDataAccessService dataAccessService = new DataAccessService(dataAccessConfigurationService);
IPrefixDefinitionRepository prefixDefinitionRepository = new PrefixDefinitionRepository(dataAccessService);
IUnitDefinitionRepository unitDefinitionRepository = new UnitDefinitionRepository(dataAccessService);
IFileGeneratorService fileGeneratorService = new FileGeneratorServiceMock();
IFileReaderService fileReaderService = new FileReaderServiceMock();
IUnitConversionService unitConversionService = new UnitConversionService(unitService, dataAccessService, prefixDefinitionRepository, unitDefinitionRepository, fileGeneratorService, fileReaderService);
WoxUnitResultFinder woxUnitResultFinder = new WoxUnitResultFinder(woxContextService, unitConversionService, systemService);
systemService.ApplicationDataPath = TestPath;
dataAccessService.Init();
woxUnitResultFinder.Init();
WoxContextService = woxContextService;
QueryService = queryService;
WoxUnitResultFinder = woxUnitResultFinder;
SystemService = systemService;
WoxContextService.AddQueryFetcher("unit", WoxUnitResultFinder);
}
private IEnumerable <WebAppConfiguration> GetWebAppConfigurations() => DataAccessService
.GetQuery("select profile, launcher, pattern from configuration;")
.Returning <WebAppConfiguration>()
.Reading("profile", (WebAppConfiguration configuration, string value) => configuration.Profile = value)
.Reading("launcher", (WebAppConfiguration configuration, string value) => configuration.WebAppLauncher = value)
.Reading("pattern", (WebAppConfiguration configuration, string value) => configuration.WebAppArgumentPattern = value)
.Execute();
private async Task <(bool success, string errorMessage)> AppendTransactions(List <Transaction> result, DbWallet wallet)
{
var transactionsApiResult = await FetchTransactions(wallet);
if (!string.IsNullOrEmpty(transactionsApiResult.Error))
{
return(false, transactionsApiResult.Error);
}
var transactionsFromApi = transactionsApiResult.Result.ToDictionary(x => GetKey(x.TxId, IsSend(x.Category)), x => x, StringComparer.InvariantCulture);
var transactionsFromDb = DataAccessService.GetTransactions(wallet.Id).ToDictionary(x => GetKey(x.TxId, x.Category), x => x, StringComparer.InvariantCulture);
var transactionsToInsertOrUpdate = new List <DbTransactionParam>(transactionsFromApi.Count);
foreach (var transaction in transactionsFromApi)
{
AppendTransaction(transaction, result, transactionsToInsertOrUpdate, transactionsFromDb);
}
if (transactionsToInsertOrUpdate.Count > 0)
{
if (!DataAccessService.InsertOrUpdateTransactions(wallet.Id, transactionsToInsertOrUpdate.ToArray()))
{
return(success : false, errorMessage : "Please try again later.");
}
}
return(true, string.Empty);
string GetKey(string txId, bool send)
{
return($"{txId}_{(send ? 1 : 0)}");
}
}
private async Task GetOrders()
{
DataAccessService dataService = new DataAccessService();
List <OrderHistory> orders = await(dataService.GetUserOrdersAsync(currentUser));
OrderData = new ObservableCollection <OrderHistory>(orders);
}
public void NoCatalogFileLocationTest()
{
//--Arrange
var inMemorySettings = new Dictionary <string, string> {
};
IConfiguration testConfiguration = new ConfigurationBuilder()
.AddInMemoryCollection(inMemorySettings)
.Build();
DataAccessService dataAccessService = new DataAccessService(_logMock.Object, testConfiguration);
//--Act
Hashtable result = dataAccessService.GetProductCatalog();
//--Assert
// Should throw ArgumentNullException
_logMock.Verify(x => x.Log(
LogLevel.Error,
It.IsAny <EventId>(),
It.IsAny <It.IsAnyType>(),
It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()),
Times.Exactly(1));
}
public DataAccessServiceTests()
{
_scopeFactoryMock = new Mock <IServiceScopeFactory>();
_sqlBuilderMock = new Mock <ISqlQueryBuilder>();
_progressMock = new Mock <IUpdatingProgress>();
_service = new DataAccessService(_scopeFactoryMock.Object, _sqlBuilderMock.Object, _progressMock.Object);
}
protected void SetupDataAccess()
{
DataAccessService dataAccess = new DataAccessService(ConfigurationManager.ConnectionStrings["HADS18-DB"].ConnectionString);
Application.Lock();
Application.Set("DataAccess", dataAccess);
Application.UnLock();
}
private void DeleteButton_Click(object sender, EventArgs e)
{
int selectedIndex = HistoryListBox.SelectedIndex;
account.Remove(selectedIndex);
HistoryListBox.Items.RemoveAt(selectedIndex);
DataAccessService.SaveAccountItems(account);
}
/// <summary>
/// Initializes the base repository using the required parameters.
/// </summary>
/// <param name="dataAccessService"></param>
/// <param name="databaseName"></param>
/// <param name="tableName"></param>
private void Initialize(DataAccessService dataAccessService, string databaseName, string tableName)
{
dataAccessService.DatabaseName = databaseName;
DataAccessService = dataAccessService;
TableName = tableName;
this.databaseName = databaseName;
}
private IEnumerable <WebAppItem> GetWebAppItems() => DataAccessService
.GetQuery("select id, url, keywords, profile from webapp_item order by id;")
.Returning <WebAppItem>()
.Reading("id", (WebAppItem item, long value) => item.Id = value)
.Reading("url", (WebAppItem item, string value) => item.Url = value)
.Reading("keywords", (WebAppItem item, string value) => item.Keywords = value)
.Reading("profile", (WebAppItem item, string value) => item.Profile = value)
.Execute();
public void ImportNewPlotTasks()
{
var da = new DataAccessService(_connectionString);
var query = QueryTemplates.Templates.GetTemplate("Import_PJOB_from_PLT_MNGR_PLOT_TICKET").Template;
var result = da.ExecuteCommand(query);
query = QueryTemplates.Templates.GetTemplate("Import_PTASK_from_PLT_MNGR_PLOT_TICKET").Template;
result = da.ExecuteCommand(query);
}
public IssueViewModel()
{
Messenger.Default.Register <PresentationLayer.Model.Issue>(this, NotifyMe);
DataAccessService service = new DataAccessService();
var result = service.GetAllIssues();
issueList = new ObservableCollection <Model.Issue>(result);
}
public DbUpgradeManager(DataSource dataSource)
{
_dataSource = dataSource;
_dataAccess = (DataAccessService) _dataSource.App.DataAccess;
_database = _dataSource.Database;
_app = _database.DbModel.EntityApp;
_log = _app.ActivationLog;
_timeService = _app.GetService<ITimeService>();
}
public DbUpgradeManager(DataSource dataSource)
{
_dataSource = dataSource;
_dataAccess = (DataAccessService)_dataSource.App.DataAccess;
_database = _dataSource.Database;
_app = _database.DbModel.EntityApp;
_log = _app.SystemLog;
_timeService = _app.GetService <ITimeService>();
}
private void SaveConfigurationItem(string name, string value)
{
DataAccessService
.GetQuery("insert or replace into configuration (key, value) values (@key, @value)")
.WithParameter("key", name)
.WithParameter("value", value)
.Execute()
;
}
public Form1()
{
InitializeComponent();
account = DataAccessService.ReadAccountItems();
foreach (Item item in account)
{
HistoryListBox.Items.Add(item);
}
}
public bool LockPlotTask(int taskId)
{
var da = new DataAccessService(_connectionString);
var template = QueryTemplates.Templates.GetTemplate("Lock_PTASK_record").Template;
var query = string.Format(template, taskId);
var result = da.ExecuteCommand(query);
return(result == 1);
}
public PersonelViewModel()
{
DataAccessService service = new DataAccessService();
var result = service.GetAllPersonels();
var scoreResult = service.ScoreBoard();
personelList = new ObservableCollection <Model.Personel>(result);
scoreList = new ObservableCollection <Personel>(scoreResult);
}
public HttpResponseMessage GetReport(string WWID)
{
Logger.Info("WWID:" + WWID);
List <Report> objReportList = new List <Report>();
DataAccessService objservice = new DataAccessService();
objReportList = objservice.GetReporDAL(WWID);
return(Request.CreateResponse(HttpStatusCode.OK, objReportList, Configuration.Formatters.JsonFormatter));
}
public HttpResponseMessage GetQuestionsWithChoice(int gameID)
{
Logger.Info("GameID:" + gameID);
Question_bank objqb = new Question_bank();
DataAccessService objservice = new DataAccessService();
var data = objservice.GetQuestionsWithChoice(gameID);
return(Request.CreateResponse(HttpStatusCode.OK, data, Configuration.Formatters.JsonFormatter));
}
public IEnumerable <PlotTask> GetPlotTasks()
{
var da = new DataAccessService(_connectionString);
var template = QueryTemplates.Templates.GetTemplate("Retreive_PTASK_records_to_process").Template;
var query = string.Format(template, Settings.BatchSize);
var list = da.IterateOverReader(query, MapPlotTask);
return(list);
}
