public SalonUnitWorker(SalonContext context) { _context = context; Clients = new ClientRepository(_context); Workers = new WorkerRepository(_context); ChargeOfAccounts = new ChargeOfAccountRepository(_context); }
public void TestBookingRequest() { var request = new BookingRequest { BookingId = "", Guest = new Customer { EMailAddress = "*****@*****.**", FirstName = "Mudlappa", LastName = "Narayanappa" }, RequestedRooms = new List <RoomRequest> { new RoomRequest { RequestedRoom = new Room { Id = "1", Description = "", Title = "Delux Room" }, RoomCount = 2 } }, TravelDetails = new Itinerary { FromDate = DateTime.Now.Date.AddDays(1), ToDate = DateTime.Now.Date.AddDays(2), HotelID = "" } }; var response = new WorkerRepository().AddBooking(request); Assert.IsNotNull(response); Assert.IsNotNull(response.ConfirmationNumber); }
private Logic() { log = new DAL.Logger.Logger(); storeItems = new StoreItemRepository(); workers = new WorkerRepository(); LoggedIn += User_LoggedIn; }
public async Task CancelTask(int taskId) { var server = await WorkerRepository.GetServerByAssignedTaskId(taskId); _connectionService.SendBytes(Bytes.type["cancel_task"], server.IpAddress, server.Port); await TaskRepository.UpdateTaskStatus(taskId, "Disposed"); }
public WorkerController() { string connectionString = ConfigurationManager.ConnectionStrings["WorkerManager"].ConnectionString; repo = new WorkerRepository(connectionString); companyRepo = new CompanyRepository(connectionString); }
public OctopusAsyncRepository(IOctopusAsyncClient client, RepositoryScope repositoryScope = null) { Client = client; Scope = repositoryScope ?? RepositoryScope.Unspecified(); Accounts = new AccountRepository(this); ActionTemplates = new ActionTemplateRepository(this); Artifacts = new ArtifactRepository(this); Backups = new BackupRepository(this); BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this); CertificateConfiguration = new CertificateConfigurationRepository(this); Certificates = new CertificateRepository(this); Channels = new ChannelRepository(this); CommunityActionTemplates = new CommunityActionTemplateRepository(this); Configuration = new ConfigurationRepository(this); DashboardConfigurations = new DashboardConfigurationRepository(this); Dashboards = new DashboardRepository(this); Defects = new DefectsRepository(this); DeploymentProcesses = new DeploymentProcessRepository(this); Deployments = new DeploymentRepository(this); Environments = new EnvironmentRepository(this); Events = new EventRepository(this); FeaturesConfiguration = new FeaturesConfigurationRepository(this); Feeds = new FeedRepository(this); Interruptions = new InterruptionRepository(this); LibraryVariableSets = new LibraryVariableSetRepository(this); Lifecycles = new LifecyclesRepository(this); MachinePolicies = new MachinePolicyRepository(this); MachineRoles = new MachineRoleRepository(this); Machines = new MachineRepository(this); Migrations = new MigrationRepository(this); OctopusServerNodes = new OctopusServerNodeRepository(this); PerformanceConfiguration = new PerformanceConfigurationRepository(this); PackageMetadataRepository = new PackageMetadataRepository(this); ProjectGroups = new ProjectGroupRepository(this); Projects = new ProjectRepository(this); ProjectTriggers = new ProjectTriggerRepository(this); Proxies = new ProxyRepository(this); Releases = new ReleaseRepository(this); RetentionPolicies = new RetentionPolicyRepository(this); Schedulers = new SchedulerRepository(this); ServerStatus = new ServerStatusRepository(this); Spaces = new SpaceRepository(this); Subscriptions = new SubscriptionRepository(this); TagSets = new TagSetRepository(this); Tasks = new TaskRepository(this); Teams = new TeamsRepository(this); Tenants = new TenantRepository(this); TenantVariables = new TenantVariablesRepository(this); UserInvites = new UserInvitesRepository(this); UserRoles = new UserRolesRepository(this); Users = new UserRepository(this); VariableSets = new VariableSetRepository(this); Workers = new WorkerRepository(this); WorkerPools = new WorkerPoolRepository(this); ScopedUserRoles = new ScopedUserRoleRepository(this); UserPermissions = new UserPermissionsRepository(this); loadRootResource = new Lazy <Task <RootResource> >(LoadRootDocumentInner, true); loadSpaceRootResource = new Lazy <Task <SpaceRootResource> >(LoadSpaceRootDocumentInner, true); }
public async Task SendTask(int taskId) { await _locker.WaitAsync(); try { int[,] task = await ReadStoredTask(taskId); byte[] matrixSize = ByteConverter.GetByteMatrixSize(task); byte[] matrix = ByteConverter.GetBytes(task); byte[] buffer = new byte[268435456]; WorkerServerDto server = await WorkerRepository.GetServerByAssignedTaskId(taskId); matrixSize = matrixSize.AddPrefix(Bytes.byteDef["size_prefix"]); matrix = matrix.AddPrefix(Bytes.byteDef["task_prefix"]); _connectionService.SendBytes(matrixSize, server.IpAddress, server.Port); _connectionService.ReceiveBytes(ref buffer, server.IpAddress, server.Port); _connectionService.SendBytes(matrix, server.IpAddress, server.Port); _connectionService.ReceiveBytes(ref buffer, server.IpAddress, server.Port); await TaskRepository.UpdateTaskStatus(taskId, "Working"); } finally { _locker.Release(); } }
public async Task CollectResultIfReady(int taskId) { byte[] buffer = new byte[268435456]; var server = await WorkerRepository.GetServerByAssignedTaskId(taskId); var task = await TaskRepository.GetTask(taskId); var matrix = new int[task.Size, task.Size]; _connectionService.SendBytes(Bytes.type["collect_data"], server.IpAddress, server.Port); _connectionService.ReceiveBytes(ref buffer, server.IpAddress, server.Port); if (buffer[0] == Bytes.byteDef["ready_prefix"]) { buffer = buffer.RemovePrefix(); ByteConverter.SetMatrixFromBytes(buffer, ref matrix); StoreTaskResult(matrix, taskId); await TaskRepository.UpdateTaskStatus(taskId, "Done"); await TaskRepository.UnAssignTask(taskId); } else if (buffer[0] == Bytes.byteDef["notyet_prefix"]) { return; } }
public UnitOfWork(RestaurantContext context) { _context = context; Adjustments = new AdjustmentRepository(_context); AdjustmentsItems = new AdjustmentItemRepository(_context); Branches = new BranchRepository(_context); Categories = new CategoryRepository(_context); Customers = new CustomerRepository(_context); Deliveries = new DeliveryRepository(_context); DeliveryItems = new DeliveryItemRepository(_context); Divisions = new DivisionRepository(_context); Expirations = new ExpirationRepository(_context); Groups = new GroupRepository(_context); Stocks = new InventoryItemRepository(_context); Locations = new LocationRepository(_context); Units = new MeasurementUnitRepository(_context); Productions = new ProductionRepository(_context); Ingredients = new ProductionItemRepository(_context); Products = new ProductRepository(_context); Purchases = new PurchaseRepository(_context); PurchaseItems = new PurchaseItemRepository(_context); PurchaseOrders = new PurchaseOrderRepository(_context); PurchaseOrderItems = new PurchaseOrderItemRepository(_context); SalesInvoices = new SalesInvoiceRepository(_context); SalesInvoiceItems = new SalesInvoiceItemRepository(_context); Suppliers = new SupplierRepository(_context); Transfers = new TransferRepository(_context); TransferItems = new TransferItemRepository(_context); Wastages = new WastageRepository(_context); WastageItems = new WastageItemRepository(_context); Workers = new WorkerRepository(_context); ItemLocation = new ItemLocationRepository(_context); StockHistory = new StockHistoryRepository(_context); Currencies = new CurrencyRepository(_context); }
public ActionResult WorkerProfile() { var workerModel = new WorkerRepository(new BaseContext()) .getWorkerModel(User.Identity.GetUserId <int>()); return(View(workerModel)); }
public List <Notification> GetNotifications() { var notifications = new List <Notification>(); var trucksLink = "/Truck/EditTruck?truckId={0}"; var workersLink = "/Worker/EditWorker?workerId={0}"; var trucks = new TruckRepository().GetTrucks(); var workers = new WorkerRepository().GetWorkers(); foreach (var truck in trucks) { var pageLink = string.Format(trucksLink, truck.Id); notifications.Add(GetNotificationForDate(NotificationWarnnings.ITPWillExpire, NotificationWarnnings.ITPExpired, truck.ITPExpirationDate, truck.ITPExpirationDateString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.InsuranceWillExpire, NotificationWarnnings.InsuranceExpired, truck.InsuranceExpirationDate, truck.InsuranceExpirationDateString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.TahografWillExpire, NotificationWarnnings.TahografExpired, truck.TachographExpirationDate, truck.TachographExpirationDateString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.ConformCopyWillExpire, NotificationWarnnings.ConformCopyWillExpire, truck.ConformCopyExpirationDate, truck.ConformCopyExpirationDateString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.VignetteNLWillExpire, NotificationWarnnings.VignetteNLWillExpire, truck.VignetteExpirationDateNL, truck.VignetteExpirationDateNLString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.VignetteROWillExpire, NotificationWarnnings.VignetteROWillExpire, truck.VignetteExpirationDateRO, truck.VignetteExpirationDateROString, truck.RegistrationNumber, pageLink, true)); notifications.Add(GetNotificationForDate(NotificationWarnnings.VignetteUKWillExpire, NotificationWarnnings.VignetteUKExpired, truck.VignetteExpirationDateUK, truck.VignetteExpirationDateUKString, truck.RegistrationNumber, pageLink, true)); } foreach (var worker in workers) { var pageLink = string.Format(workersLink, worker.Id); notifications.Add(GetNotificationForDate(NotificationWarnnings.PermitWillExpire, NotificationWarnnings.PermitExpired, worker.DrivingLicenseExpirationDate, worker.DrivingLicenseExpirationDateString, worker.WorkerName, pageLink, false)); notifications.Add(GetNotificationForDate(NotificationWarnnings.CertificateWillExpire, NotificationWarnnings.CertificateExpired, worker.CertificateExpirationDate, worker.CertificateExpirationDateString, worker.WorkerName, pageLink, false)); notifications.Add(GetNotificationForDate(NotificationWarnnings.TahografCardWillExpire, NotificationWarnnings.TahografCardExpired, worker.TachographCardExpirationDate, worker.TachographCardExpirationDateString, worker.WorkerName, pageLink, false)); notifications.Add(GetNotificationForDate(NotificationWarnnings.MedicalWillExpire, NotificationWarnnings.MedicalExpired, worker.MedicalTestsExpirationDate, worker.MedicalTestsExpirationDateString, worker.WorkerName, pageLink, false)); } notifications = GetNotificationThatAreNotNull(notifications); return(notifications.OrderByDescending(x => x.NotificationDate).ToList()); }
public WorkerData() { InitializeComponent(); _worker = new WorkerRepository(); _position = new PositionRepository(); _company = new CompanyRepository(); }
public void TestCancellationRequest() { var request = new CancellationRequest { BookingNumber = "D35F673C-728F-447C-9872-F6F8D05CE0C7", ConfirmationNumber = "100", LastName = "Narayanappa" }; var response = new WorkerRepository().CancelBooking(request); Assert.IsNotNull(response); }
public UnitOfWork(DbContextOptions contextOptions) { _context = new DatabaseContext(contextOptions); Employers = new EmployerRepository(_context); Workers = new WorkerRepository(_context); Migrate(); }
public UnitOfWork() { context = new Context(); Enrollments = new EnrollmentRepository(context); Positions = new PositionRepository(context); Workers = new WorkerRepository(context); WorkerPositions = new WorkerPositionRepository(context); }
public EditWorker() { InitializeComponent(); _worker = new WorkerRepository(); _company = new CompanyRepository(); _position = new PositionRepository(); birthDate.MaximumDate = DateTime.Now; birthDate.MinimumDate = DateTime.Now.AddYears(-100); }
public RequestsDistributor(IHubContext <DistributeHub, ITypedHubClient> hub) { var Context = new UnitOfWork(); workerRepository = Context.Repository <Worker>() as WorkerRepository; requestRepository = Context.Repository <Request>() as RequestRepository; settingsRepository = Context.Repository <Settings>() as SettingsRepository; hubContext = hub; }
public async Task UpdateTaskProgress(int taskId) { byte[] buffer = new byte[268435456]; var server = await WorkerRepository.GetServerByAssignedTaskId(taskId); _connectionService.SendBytes(Bytes.type["progress_request"], server.IpAddress, server.Port); _connectionService.ReceiveBytes(ref buffer, server.IpAddress, server.Port); buffer = buffer.RemovePrefix(); await TaskRepository.UpdateTaskPercent(taskId, buffer[0]); }
public void TestReservationStatus() { var request = new BookingStatusRequest { BookingNumber = "D35F673C-728F-447C-9872-F6F8D05CE0C7", LastName = "Narayanappa" }; var response = new WorkerRepository().GetBookingStatus(request); Assert.IsNotNull(response); Assert.IsNotNull(response.StatusCode); }
public FluentRecordBase AddRepoWorker() { if (_dbFactory == null) { AddDBFactory(); } _repoW = new WorkerRepository(_dbFactory); return(this); }
public Worker CreateWorker(WorkerRequest Worker) { var entityToInsert = new Worker() { User = this.UserRepository.GetById(Worker.UserId) }; WorkerRepository.Insert(entityToInsert); return(entityToInsert); }
public Worker GetById(int WorkerId) { var Worker = WorkerRepository.GetById(WorkerId); if (Worker == null) { throw new BadRequestException(ErrorMessages.TrabajadorNoEncontrado); } return(Worker); }
/// <summary> /// Creates a new instance of the CmsWorker class /// </summary> /// <param name="workerRepository">A worker repository to store event data in</param> /// <param name="logEntryRepository">A LogEntry repository implementation to use when building the underlying logger</param> /// <param name="errorRepository">An Error repository implementation for handling the creation of worker errors</param> /// <param name="messageBus">An optional message bus to use for the worker and logger</param> public CmsWorker(WorkerRepository workerRepository, IRepository <LogEntry> logEntryRepository, IRepository <AuditableError> errorRepository, MessageBus messageBus = null) { this.MessageBus = messageBus; this.Logger = new Logger(this, messageBus, logEntryRepository, errorRepository); this.WorkerRepository = workerRepository; MessageBus.SubscribeAll(TypeFactory.GetAllImplementations(typeof(IMessageHandler))); this.UpdateLastRun(); }
public OctopusAsyncRepository(IOctopusAsyncClient client) { this.Client = client; Accounts = new AccountRepository(client); ActionTemplates = new ActionTemplateRepository(client); Artifacts = new ArtifactRepository(client); Backups = new BackupRepository(client); BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client); CertificateConfiguration = new CertificateConfigurationRepository(client); Certificates = new CertificateRepository(client); Channels = new ChannelRepository(client); CommunityActionTemplates = new CommunityActionTemplateRepository(client); Configuration = new ConfigurationRepository(client); DashboardConfigurations = new DashboardConfigurationRepository(client); Dashboards = new DashboardRepository(client); Defects = new DefectsRepository(client); DeploymentProcesses = new DeploymentProcessRepository(client); Deployments = new DeploymentRepository(client); Environments = new EnvironmentRepository(client); Events = new EventRepository(client); FeaturesConfiguration = new FeaturesConfigurationRepository(client); Feeds = new FeedRepository(client); Interruptions = new InterruptionRepository(client); LibraryVariableSets = new LibraryVariableSetRepository(client); Lifecycles = new LifecyclesRepository(client); MachinePolicies = new MachinePolicyRepository(client); MachineRoles = new MachineRoleRepository(client); Machines = new MachineRepository(client); Migrations = new MigrationRepository(client); OctopusServerNodes = new OctopusServerNodeRepository(client); PerformanceConfiguration = new PerformanceConfigurationRepository(client); ProjectGroups = new ProjectGroupRepository(client); Projects = new ProjectRepository(client); ProjectTriggers = new ProjectTriggerRepository(client); Proxies = new ProxyRepository(client); Releases = new ReleaseRepository(client); RetentionPolicies = new RetentionPolicyRepository(client); Schedulers = new SchedulerRepository(client); ServerStatus = new ServerStatusRepository(client); Subscriptions = new SubscriptionRepository(client); TagSets = new TagSetRepository(client); Tasks = new TaskRepository(client); Teams = new TeamsRepository(client); Tenants = new TenantRepository(client); TenantVariables = new TenantVariablesRepository(client); UserRoles = new UserRolesRepository(client); Users = new UserRepository(client); VariableSets = new VariableSetRepository(client); Workers = new WorkerRepository(client); WorkerPools = new WorkerPoolRepository(client); }
public void RegisterAndRetrieveWorkers() { var repo = new WorkerRepository(); repo.RegisterWorker(new WorkerA()); var workerA = repo.RetrieveWorkerForWorkItem(new WorkItemA()); Assert.IsTrue(workerA is WorkerA); repo.RegisterWorker(new WorkerB()); var workerB = repo.RetrieveWorkerForWorkItem(new WorkItemB()); Assert.IsTrue(workerB is WorkerB); }
public override void SetWorkingHours(int hours, string date) { if (DateTime.Parse(date) > DateTime.Today) { throw new ArgumentException("Дата не может быть позже сегодняшнего дня!"); } WorkerRepository.SetFileName(this); WorkerRepository.LoadWorkersToString(); RefactorStringParameters.Worker = this; var parameters = RefactorStringParameters.FindOrCreateNewNote(date, hours); RefactorStringParameters.RefactorListWorkers(parameters, hours, date); WorkerRepository.ListWorkers.Sort(); WorkerRepository.WriteWorkersToString(); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { _logger.LogInformation("Started jobs at: {time}", DateTimeOffset.Now); var servers = await WorkerRepository.GetWorkerServer(); _logger.LogInformation("Loaded servers: {0}", servers.Count); servers.ForEach(s => _connectionService.ConnectToExistingServer(s.IpAddress, s.Port)); var unassignedTasks = await _computeTaskService.GetUnassignedTasks(); _logger.LogInformation("Got unassigned tasks: {0}", unassignedTasks.Count); await unassignedTasks.ForEachAsync(async t => await _computeTaskService.AssignTask(t.TaskID)); var taskToCancel = await _computeTaskService.GetCanceledTasks(); await taskToCancel.ForEachAsync(async t => await _computeTaskService.CancelTask(t.TaskID)); var assignedTasksId = await _computeTaskService.GetIdToSendList(); _logger.LogInformation("Got assigned tasks: {0}", assignedTasksId.Count); await assignedTasksId.ForEachAsync(async t => await _computeTaskService.SendTask(t)); var workingTasks = await TaskRepository.GetWorkingTasks(); await workingTasks.ForEachAsync(async t => await _computeTaskService.UpdateTaskProgress(t.TaskID)); _logger.LogInformation("Updated tasks progress"); await workingTasks.ForEachAsync(async t => await _computeTaskService.CollectResultIfReady(t.TaskID)); _logger.LogInformation("Checked tasks results"); _locker.Release(); } catch (Exception e) { _logger.LogError(e.Message); } await Task.Delay(TimeSpan.FromSeconds(2), stoppingToken); } }
public ActionResult Login(LoginModel data) { IWorkerRepository workerRepository = new WorkerRepository(); bool workerExist = workerRepository.LogIn(data.Login, data.Password); if (ModelState.IsValid && workerExist != false) { string cookieValue = data.Login.ToString(); var cookie = new HttpCookie("LogOn", cookieValue); Response.AppendCookie(cookie); return(RedirectToAction("OrderList", "Order")); } else { return(View()); } }
public List <Worker> GetAll() { var users = WorkerRepository.GetAll(); if (users == null) { throw new BadRequestException(ErrorMessages.UserNoEncontrado); } var result = new List <Worker>(); var enumerator = users.GetEnumerator(); while (enumerator.MoveNext()) { result.Add(enumerator.Current); } return(result); }
public async Task <bool> EstablishConnection(string ipAddress, int port = 9915) { try { connectionsDictionary.Add(ParseIpPort(ipAddress, port), _connectionFactory.GenerateConnection(ipAddress, port)); await WorkerRepository.AddNewWorkerServer(new WorkerServerDto { IpAddress = ipAddress, IsConnected = true, Port = port }); return(true); } catch { return(false); } }