public async Task <IHttpActionResult> PostEvent([FromBody] TicketEvent tEvent)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "PostEvent", GetServiceProperties());
try
{
TicketEvent.Validate(tEvent);
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
var id = await dataService.CreateEvent(tEvent);
return(Ok(await dataService.GetEventById(id)));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
static async Task Main(string[] args)
{
_datageneratorservice = new DataGeneratorService();
_datastoreservice = new DataStoreService();
await Init();
try
{
Console.WriteLine("Truncating sensors table before start pushing data");
_datastoreservice.TruncateRealtimeSensorRecordTable();
}
catch (Exception e)
{
Console.WriteLine("Error truncating table: " + e.Message);
}
Console.WriteLine($"Starting writing realtime records with {PushTimeInterval} millisecond interval to database...");
while (true)
{
if (!BlockedDataGeneration)
{
var records = _datageneratorservice.GenerateRealTimeSensorRecords(StopWake);
Console.WriteLine($"[{DateTime.Now}] Writing records to db.");
_datastoreservice.WriteSensorRecordsToDB(records);
}
await Task.Delay(PushTimeInterval);
}
}
public ExchangeDataController(IConfiguration configuration, IDataGovRuService dataGovRuService,
IFileService fileService, ITextFileParser parser, IDataStoreService dataService)
{
_configuration = configuration;
_dataGovRuService = dataGovRuService;
_fileService = fileService;
_dataService = dataService;
_parser = parser;
}
public LookupPickerPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService, IDataStoreService dataStoreService)
: base(navigationService, pageDialogService)
{
_dataStoreService = dataStoreService;
//_dataStoreService.SyncCodeValueLookup();
//_dataStoreService.SyncAccessionLookup();
_restClient = new RestClient();
SearchTextCommand = new DelegateCommand(OnSearchTextCommandExecuted);
ItemTappedCommand = new DelegateCommand <object>(OnItemTappedCommandExecuted);
}
public FilePayloadUploadProvider(IFileDownloadDatabaseService fileDownloadDatabaseService,
IDataStoreServiceFactory dataStoreServiceFactory,
IFileValidationService fileValidationService)
{
this.fileDownloadDatabaseService = fileDownloadDatabaseService
?? throw new ArgumentNullException(nameof(fileDownloadDatabaseService));
this.fileValidationService =
fileValidationService ?? throw new ArgumentNullException(nameof(fileValidationService));
dataStoreService = dataStoreServiceFactory?.Create()
?? throw new ArgumentNullException(nameof(dataStoreService));
}
public StatsDownloadApiDataStoreProvider(IDataStoreServiceFactory dataStoreServiceFactory,
IStatsDownloadApiDatabaseService databaseService,
IFileValidationService fileValidationService,
IFilePayloadApiSettingsService filePayloadApiSettingsService,
ILoggingService loggingService)
{
dataStoreService = dataStoreServiceFactory.Create();
this.databaseService = databaseService;
this.fileValidationService = fileValidationService;
this.filePayloadApiSettingsService = filePayloadApiSettingsService;
this.loggingService = loggingService;
}
public async Task <IHttpActionResult> GetOrdersByUserName(string username)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "GetOrdersByUserName", GetServiceProperties());
try
{
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
return(Ok(await dataService.GetOrdersByUserName(username)));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public async Task <IHttpActionResult> GetEvents()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "GetEvents", GetServiceProperties());
try
{
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
var itemsList = await dataService.GetEvents();
return(Ok(itemsList.OrderBy(p => p.EndDate).ToList()));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public FileDownloadProvider(IFileDownloadDatabaseService fileDownloadDatabaseService,
IFileDownloadLoggingService loggingService, IDownloadService downloadService,
IFilePayloadSettingsService filePayloadSettingsService,
IResourceCleanupService resourceCleanupService,
IFileDownloadMinimumWaitTimeService fileDownloadMinimumWaitTimeService,
IDateTimeService dateTimeService,
IFilePayloadUploadService filePayloadUploadService,
IFileDownloadEmailService fileDownloadEmailService,
IDataStoreServiceFactory dataStoreServiceFactory)
{
this.fileDownloadDatabaseService = fileDownloadDatabaseService;
this.loggingService = loggingService;
this.downloadService = downloadService;
this.filePayloadSettingsService = filePayloadSettingsService;
this.resourceCleanupService = resourceCleanupService;
this.fileDownloadMinimumWaitTimeService = fileDownloadMinimumWaitTimeService;
this.dateTimeService = dateTimeService;
this.filePayloadUploadService = filePayloadUploadService;
this.fileDownloadEmailService = fileDownloadEmailService;
dataStoreService = dataStoreServiceFactory?.Create();
ValidateCtorArgs();
}
public async Task <IHttpActionResult> DeleteAllLogMessges()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "DeleteAllLogMessges", GetServiceProperties());
try
{
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
await dataService.DeleteAllLogMessages();
return(Ok("Done"));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public OtherViewModel(IDataStoreService <Item> dataStoreService)
{
dataStoreService = _dataStoreService;
GetData();
}
public AuthController(IDataStoreService dataStore)
{
_dataStore = dataStore;
}
public List<Authorization> Test_GetUsersAuthentications(IDataStoreService store, string username, List<Role> usersRoles)
{
return this.GetUsersAuthentications(store, username, usersRoles);
}
public PropertiesController(IDataRetrieveService dataRetrieveService, IDataStoreService dataStoreService)
{
this.dataRetrieveService = dataRetrieveService;
this.dataStoreService = dataStoreService;
}
public ContactsController(IDataStoreService dataStoreService)
{
_DataStoreService = dataStoreService;
}
public AuthIdentityTestService(string username, IDataStoreService store)
: base(username, new DataStoreFactory(store))
{
}
public DataStore()
{
_service = LemonTransform.Container.Resolve <IDataStoreService>();
}
protected List<Role> GetUsersRolesRecursive(IDataStoreService ctx, string username, Dictionary<RoleKey, List<Role>> roleMemberLookup)
{
// get a list of roles the member is directly a member of
var directRoles = ctx.Roles.Where(f => f.Users.Any(g => g.User.Username == username)).AsEnumerable().Select(f => new RoleKey(f.Name, f.OrganizationId));
return roleMemberLookup.Where(f => directRoles.Any(g => g.Name == f.Key.Name && g.OrgId == f.Key.OrgId)).SelectMany(f => f.Value).Distinct().ToList();
}
public AccountService(IDataStoreService dataStoreService, IConfigurationService configurationService, ICalculationService calculationService)
{
_dataStoreService = dataStoreService;
_calculationService = calculationService;
_dataStoreType = configurationService.GetAppSettingForKey(Constants.DataStoreTypeKey);
}
/// <summary>
/// By applying dependency injection we make the purpose of the service more clear and segment the additional
/// responsitibilities
/// into injectable components
/// </summary>
public PaymentService(IDataStoreService dataStoreService, ILogService logService, IRulesService rulesService)
{
DataStoreService = dataStoreService;
LogService = logService;
RulesService = rulesService;
}
public DialUpController(IDataStoreService dataStoreService)
{
_DataStoreService = dataStoreService;
}
public DataStoreFactory(IDataStoreService service)
{
this.sharedInstance = service;
}
public ViewModelBase()
{
NavigationService = ViewModelLocator.Instance.Resolve <INavigationService>();
DataStoreService = ViewModelLocator.Instance.Resolve <IDataStoreService>();
}
protected Dictionary<RoleKey, List<Role>> GetRoleMemberLookup(IDataStoreService store)
{
var roleMap = store.Roles.IncludePaths("MemberOfRoles", "Organization").ToList();
return roleMap.ToDictionary(f => new RoleKey(f.Name, f.OrganizationId), f => f.Flatten().Distinct().ToList());
}
public async Task <IHttpActionResult> UpdateServiceHealthState(UpdateHealthRequest request)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "UpdateServiceHealthState", GetServiceProperties());
try
{
UpdateHealthRequest.Validate(request);
int ticketOrderServices = 0;
int ticketOrderActors = 0;
int eventActors = 0;
ServiceLocationService locator = new ServiceLocationService();
UriBuilderService builder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsTicketOrderServiceName);
ServicePartitionList partitions = await _fabricClient.QueryManager.GetPartitionListAsync(builder.ToUri());
foreach (Partition p in partitions)
{
long minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey;
ITicketOrderService dispenderService = locator.Create <ITicketOrderService>(builder.ToUri());
await dispenderService.UpdateHealthState(GetHealthStateFromString(request.State), request.Message);
ticketOrderServices++;
}
ActorLocationService actorLocator = new ActorLocationService();
UriBuilderService orderActorBuilder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsTicketOrderActorName);
ServicePartitionList orderActorPartitions = await _fabricClient.QueryManager.GetPartitionListAsync(orderActorBuilder.ToUri());
foreach (Partition p in orderActorPartitions)
{
string minKey = (p.PartitionInformation as Int64RangePartitionInformation).Id.ToString();
ITicketOrderActor actor = actorLocator.Create <ITicketOrderActor>(new ActorId(minKey), Constants.ContosoEventsApplicationName);
await actor.UpdateHealthState(GetHealthStateFromString(request.State), request.Message);
ticketOrderActors++;
// May require contiunuation
}
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
List <TicketEvent> events = await dataService.GetEvents();
UriBuilderService eventActorBuilder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsEventActorName);
foreach (var tEvent in events)
{
IEventActor actor = actorLocator.Create <IEventActor>(new ActorId(tEvent.Id), Constants.ContosoEventsApplicationName);
await actor.UpdateHealthState(GetHealthStateFromString(request.State), request.Message);
eventActors++;
// May require contiunuation
}
return(Ok("Done: " + ticketOrderServices + "|" + ticketOrderActors + "|" + eventActors));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
protected List<Authorization> GetUsersAuthentications(IDataStoreService store, string username, List<Role> usersRoles)
{
var roleAuths = store.Authorization.Where(f => f.RoleId != null);
var authList = (from have in usersRoles join granted in roleAuths on have.Id equals granted.RoleId select granted).ToList();
authList.AddRange(store.Authorization.Where(f => f.UserName == username));
return authList;
}
public DefaultKuKey(IDataStoreService dataSrv, IEncryptService encryptSrv)
{
DataStoreService = dataSrv;
EncryptService = encryptSrv;
}
/// <summary>
/// constructor injection of the date store service was used here,
/// to make the service available to all controller requests
/// </summary>
/// <param name="dataSvc">data store service instance</param>
public VendingMachineService(IDataStoreService <CoffeeModel> dataSvc)
{
_dataSvc = dataSvc;
}
public AccountService(IDataStoreService dataStoreService)
{
// See constructor test case GetAccountEmpty()
_dataStoreService = dataStoreService;
_dataStoreConfigKey = GetAppSettingForKey("DataStoreType");
}
public NotificationService(ISettingService setting, ILoggerService logger, IDataStoreService dataStore)
{
_settingService = setting;
_loggerService = logger;
_dataStoreService = dataStore;
}
public TestsController(IDataStoreService <Test> testDataStoreService)
{
_testDataStoreService = testDataStoreService;
}
public Dictionary<RoleKey, List<Role>> Test_GetRoleMemberLookup(IDataStoreService store)
{
return this.GetRoleMemberLookup(store);
}
public PaymentService(IDataStoreService IDataStoreService, INotificationService INotificationService)
{
_IDataStoreService = IDataStoreService;
_INotificationService = INotificationService;
}
public List<Role> Test_GetUsersRolesRecursive(IDataStoreService ctx, string username, Dictionary<RoleKey, List<Role>> roleMemberLookup)
{
return this.GetUsersRolesRecursive(ctx, username, roleMemberLookup);
}
public ProductService(IDataStoreService dataStoreService)
{
_dataStoreService = dataStoreService;
}
public DataStore()
{
_service = LemonTransform.Container.Resolve<IDataStoreService>();
}
public TestChildrenController(ITestChildrenDataStoreService testChildrenDataStoreService, IDataStoreService <Test> testDataStoreService)
{
_testChildrenDataStoreService = testChildrenDataStoreService;
_testDataStoreService = testDataStoreService;
}
public INotificationService GetNotificationService(ISettingService setting, ILoggerService logger, IDataStoreService dataStore)
{
return(new NotificationService(setting, logger, dataStore));
}
public DefaultKuKey(string databasePath, string masterPassword)
{
DataStoreService = new SQLiteDataStoreService(databasePath);
EncryptService = new AESEncryptService(masterPassword);
}
