Ejemplo n.º 1
0
 public Services(
     IEntryService entryService,
     IUserService userService,
     IConfigService configService,
     IMessageService messageService,
     ICloudService cloudService)
 {
     Entry = entryService;
     User = userService;
     Config = configService;
     Message = messageService;
     Cloud = cloudService;
 }
Ejemplo n.º 2
0
        public CloudLibraryService(ICloudService cloudService, ILibraryService libraryService, IAudioFileCacheService audioFileCacheService,
            ISyncDeviceSpecifications deviceSpecifications)
        {
            _cloudService = cloudService;
            _libraryService = libraryService;
            _audioFileCacheService = audioFileCacheService;
            _deviceSpecifications = deviceSpecifications;

            _deviceInfos = new List<CloudDeviceInfo>();
            _deviceInfosLeftToDownload = new List<string>();

            Initialize();
        }
Ejemplo n.º 3
0
        public TaskListViewModel()
        {
            Debug.WriteLine("In TaskListViewMOdel");
            cloudService = ServiceLocator.Instance.Resolve <ICloudService>();
            Table        = cloudService.GetTable <TodoItem>();

            Title = "Task List";
            items.CollectionChanged += this.OnCollectionChanged;

            RefreshCommand    = new Command(async() => await ExecuteRefreshCommand());
            AddNewItemCommand = new Command(async() => await ExecuteAddNewItemCommand());
            LogoutCommand     = new Command(async() => await ExecuteLogoutCommand());

            // Execute the refresh command
            RefreshCommand.Execute(null);
        }
Ejemplo n.º 4
0
 public ProductsService(
     IDeletableEntityRepository <MenuProduct> productsRepo,
     ICloudService cloudService,
     IRepository <Allergen> allergensRepository,
     IRepository <Category> categoriesRepository,
     IDeletableEntityRepository <Package> packageRepository,
     IDeletableEntityRepository <ProductSize> sizeRepository,
     IDeletableEntityRepository <AllergensProducts> allergensProductsRepository)
 {
     this.productsRepo                = productsRepo;
     this.cloudService                = cloudService;
     this.allergensRepository         = allergensRepository;
     this.categoriesRepository        = categoriesRepository;
     this.packageRepository           = packageRepository;
     this.sizeRepository              = sizeRepository;
     this.allergensProductsRepository = allergensProductsRepository;
 }
 public SalesOrderWorkItemRepository(
     IConfigurationService configurationService,
     ISalesOrderUpdateNotificationRepository salesOrderUpdateNotificationRepository,
     ISalesOrderItemRepository salesOrderItemRepository,
     ICloudService cloudService,
     ISyncService syncService,
     ILogService logService,
     string userIdConfigKey
     )
 {
     _configurationService = configurationService;
     _cloudService         = cloudService;
     _syncService          = syncService;
     _logService           = logService;
     _userIdConfigKey      = userIdConfigKey;
     _salesOrderUpdateNotificationRepository = salesOrderUpdateNotificationRepository;
     _salesOrderItemRepository = salesOrderItemRepository;
 }
Ejemplo n.º 6
0
        public async Task <JsonResult> UpdateService(string id, [FromBody] UpdateServiceHttpParams attr)
        {
            Logger.Log("Update service query. Service Id " + id);
            try
            {
                Logger.Log($"Updating service : {id} - to change, but have : {JsonConvert.SerializeObject(ServiceLogic.Services.Select(el => el.Id))}");
                ICloudService service = ServiceLogic.Services.Find(el => el.Id == id);
                Logger.Log($"Found service {service.Id} : {service.DockerServiceId}");
                bool success = await service.Update(attr.FileBase64);

                return(new JsonResult(success));
            }
            catch (Exception e)
            {
                Logger.Fail(e.Message);
                return(new JsonResult(e.Message));
            }
        }
Ejemplo n.º 7
0
 public Services(
     IEntryService entryService,
     IUserService userService,
     IConfigService configService,
     IMessageService messageService,
     ICloudService cloudService,
     IThemeService themeService,
     IAboutService aboutService,
     IImageService imageService)
 {
     Entry   = entryService;
     User    = userService;
     Config  = configService;
     Message = messageService;
     Cloud   = cloudService;
     Theme   = themeService;
     About   = aboutService;
     Image   = imageService;
 }
Ejemplo n.º 8
0
		public Services(
			IEntryService entryService,
			IUserService userService,
			IConfigService configService,
			IMessageService messageService,
			ICloudService cloudService,
			IThemeService themeService,
			IAboutService aboutService,
			IImageService imageService)
		{
			Entry = entryService;
			User = userService;
			Config = configService;
			Message = messageService;
			Cloud = cloudService;
			Theme = themeService;
			About = aboutService;
			Image = imageService;
		}
Ejemplo n.º 9
0
 public AccountController(UserManager <User, long> userManager, SignInManager <User, long> signInManager, IAuthenticationManager authManager, IUserService userService
                          , IUserVaultService uservaultService, IRepository <MFilesVault> vaultRepository, IMFilesVaultService mfvaultService
                          , ICloudService cloudService, IVaultTemplateService vaultTemplateService, IProjectService projService, IProjectMemberService projectMemberService
                          , IVaultServerService vaultserverService, IMFUserService mfuserService, IMFVaultService vaultService) //IUserCloudService usercloudService,
     : base(authManager, signInManager, userManager)
 {
     _userService = userService;
     //_usercloudService = usercloudService;
     _uservaultService     = uservaultService;
     _cloudService         = cloudService;
     _vaultTemplateService = vaultTemplateService;
     _projService          = projService;
     _projectMemberService = projectMemberService;
     _mfvaultService       = mfvaultService;
     _vaultserverService   = vaultserverService;
     _mfuserService        = mfuserService;
     _vaultService         = vaultService;
     _vaultRepository      = vaultRepository;
 }
Ejemplo n.º 10
0
 public static string UnmapFolder(ICloudService service)
 {
     try
     {
         if (service.IsInstalled)
         {
             string mappedfolder = Path.Combine(ApplicationSettings.MappedFolder, service.ApplicationName);
             string command      = string.Format("\"{0}\" -d \"{1}\" ", ResourceUtils.Junction, mappedfolder);
             return(ResourceUtils.ExecuteCommand(command, ""));
         }
         else
         {
             return("Already unmapped");
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Ejemplo n.º 11
0
        public async Task <JsonResult> CreateService([FromBody] CreateServiceHttpParams attr)
        {
            if (attr.Type == "node")
            {
                Logger.Log("Creating Node Js service");
                Logger.Log(JsonConvert.SerializeObject(attr.Dependencies));
                try
                {
                    ICloudService service = ServiceLogic.CreateCloudService(attr.Id, attr.UserId, attr.FileBase64, attr.CountOfReplicas, attr.Dependencies, attr.Type);
                    bool          success = await service.Create();

                    ServiceLogic.Services.Add(service);
                    return(new JsonResult(service));
                }
                catch (Exception e)
                {
                    Logger.Fail(e.Message);
                }
            }
            throw new Exception("Unknown type!");
        }
Ejemplo n.º 12
0
 public ProductsService(
     IDeletableEntityRepository <MenuProduct> productsRepo,
     ICloudService cloudService,
     IRepository <Allergen> allergensRepository,
     IRepository <Category> categoriesRepository,
     IDeletableEntityRepository <Package> packageRepository,
     IDeletableEntityRepository <ProductSize> sizeRepository,
     IDeletableEntityRepository <AllergensProducts> allergensProductsRepository,
     IDeletableEntityRepository <ShopingCartItem> itemRepository,
     IImageService imageService)
 {
     this.productsRepo                = productsRepo;
     this.cloudService                = cloudService;
     this.allergensRepository         = allergensRepository;
     this.categoriesRepository        = categoriesRepository;
     this.packageRepository           = packageRepository;
     this.sizeRepository              = sizeRepository;
     this.allergensProductsRepository = allergensProductsRepository;
     this.itemRepository              = itemRepository;
     this.imageService                = imageService;
 }
Ejemplo n.º 13
0
 public static string MapFolder(ICloudService service)
 {
     try
     {
         if (service.IsInstalled)
         {
             string mappedfolder = Path.Combine(ApplicationSettings.MappedFolder, service.ApplicationName);
             string command      = string.Format("\"{0}\"", ResourceUtils.Junction);
             string parameters   = string.Format("\"{0}\" \"{1}\"", mappedfolder, service.ClientFolder);
             return(ResourceUtils.ExecuteCommand(command, parameters));
         }
         else
         {
             return("NOT MAPPED... Service is not installed on this machine.");
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 public LoginViewModel(
     IServiceBundle serviceBundle,
     ISyncService syncService,
     ICloudService cloudService,
     IRepository <Branch> branchRepository,
     IRepository <SalesOrderItem> salesOrderItemRepository,
     IRepository <InboundShipment> inboundShipmentRepository,
     IRepository <InboundTransfer> inboundTransferRepository,
     IRepository <SalesOrder> salesOrderRepository,
     IRepository <Lot> lotRepository
     ) : base(serviceBundle)
 {
     _syncService               = syncService;
     _cloudService              = cloudService;
     _branchRepository          = branchRepository;
     _salesOrderItemRepository  = salesOrderItemRepository;
     _inboundShipmentRepository = inboundShipmentRepository;
     _inboundTransferRepository = inboundTransferRepository;
     _salesOrderRepository      = salesOrderRepository;
     _lotRepository             = lotRepository;
     LocalAccounts              = new List <UserModel>();
 }
Ejemplo n.º 15
0
        public ItemDetailViewModel(TodoItem item = null)
        {
            if (item != null)
            {
                Item  = item;
                Title = item.Text;
            }
            else
            {
                Item = new TodoItem {
                    Text = "New Item", Complete = false
                };
                Title = "New Item";
            }

            cloudService = ServiceLocator.Instance.Resolve <ICloudService>();

            if ((cloudService != null) && (item.TagId != null))
            {
                Tag = cloudService.GetTagByIdAsync(item.TagId).Result;
            }
        }
Ejemplo n.º 16
0
        private async Task <bool> makeReinitAsync(ReinitServiceHttpParams reinit, List <ReinitServiceHttpParams> attr, List <SwarmService> servicesList)
        {
            SwarmService swarmService = servicesList.Find(service => service.ID == reinit.DockerServiceId);

            Logger.Log($"Reinit service  : {reinit.Id}, {reinit.DockerServiceId}, serviceList : {JsonConvert.SerializeObject(servicesList.Select(el => el.ID))}");
            string dockerName = $"{reinit.UserId}-{reinit.Id}";

            if (swarmService != null)
            {
                ICloudService service = ServiceLogic.CreateCloudService(reinit.Type);
                await service.Reinitialize(reinit, swarmService);

                ServiceLogic.Services.Add(service);
            }
            else
            {
                ICloudService service = ServiceLogic.CreateCloudService(reinit.Id, reinit.UserId, reinit.FileBase64, reinit.CountOfReplicas, reinit.Dependencies, reinit.Type);
                ServiceLogic.Services.Add(service);
                await service.Create();
            }
            return(true);
        }
Ejemplo n.º 17
0
        public static TestServer BuildTestServerWithFakes(
            ITasksGroupService tasksGroupService = null,
            IWorkTaskService workTaskService     = null,
            INoteService noteService             = null,
            ICloudService cloudService           = null)
        {
            if (tasksGroupService == null)
            {
                tasksGroupService = A.Fake <ITasksGroupService>();
            }

            if (workTaskService == null)
            {
                workTaskService = A.Fake <IWorkTaskService>();
            }

            if (noteService == null)
            {
                noteService = A.Fake <INoteService>();
            }

            if (cloudService == null)
            {
                cloudService = A.Fake <ICloudService>();
            }

            TestServer testServer = new TestServer(WebHost.CreateDefaultBuilder()
                                                   .ConfigureTestServices(sc =>
            {
                sc.AddSingleton(tasksGroupService);
                sc.AddSingleton(workTaskService);
                sc.AddSingleton(noteService);
                sc.AddSingleton(cloudService);
            })
                                                   .UseStartup <Startup>()
                                                   .UseEnvironment("Development"));

            return(testServer);
        }
Ejemplo n.º 18
0
        public TaskDetailViewModel(TodoItem item = null)
        {
            ICloudService cloudService = ServiceLocator.Instance.Resolve <ICloudService>();

            Table = cloudService.GetTable <TodoItem>();

            if (item != null)
            {
                Item  = item;
                Title = item.Text;
            }
            else
            {
                Item = new TodoItem {
                    Text = "New Item", Complete = false
                };
                Title = "New Item";
            }

            SaveCommand   = new Command(async() => await ExecuteSaveCommand());
            DeleteCommand = new Command(async() => await ExecuteDeleteCommand());
        }
Ejemplo n.º 19
0
        public ItemDetailViewModel(TodoItem item = null)
        {
            if (item != null)
            {
                Item  = item;
                Title = item.Text;
            }
            else
            {
                Item = new TodoItem {
                    Text = "New Item", Complete = false
                };
                Title = "New Item";
            }
            cloudService = ServiceLocator.Instance.Resolve <ICloudService>();

            // Load the Images async
            Images = new ObservableCollection <TodoItemImage>();
#pragma warning disable CS4014 // Statement is not awaited
            LoadImagesAsync();
#pragma warning restore CS4014 // Statement is not awaited
        }
Ejemplo n.º 20
0
        public async Task ExecuteAcceptAttendeeCommand()
        {
            //Charge Customer
            //var stripeService = ServiceLocator.Instance.Resolve<IStripeProvider>();
            //string id;
            //var loginProvider = DependencyService.Get<ILoginProvider>();
            //Account acc = loginProvider.RetreiveAccountFromSecureStore();
            //acc.Properties.TryGetValue(Constants.stripeAccountIdPropertyName, out id);
            //
            //string JParty = JsonConvert.SerializeObject(partyDetails);
            //
            //StripeCharge stripeCharge = new StripeCharge()
            //{
            //    amount = price,
            //    customerId = customerid,
            //    currency = "dkk",
            //    receiverId = id, //This users id
            //    partyId = partyid,
            //    ObjectJson = JParty
            //};
            //StripeResponse response = await stripeService.ChargeCustomer(stripeCharge);

            //Update Table
            cloudService = ServiceLocator.Instance.Resolve <ICloudService>();
            var             Table    = cloudService.GetTable <AttendeeDetails>();
            AttendeeDetails attendee = new AttendeeDetails()
            {
                Id        = attendeeID,
                userId    = this.userId,
                partyId   = this.partyID,
                UpdatedAt = DateTime.Now,
                accepted  = true,
                declined  = false
            };
            await Table.UpdateItemAsync(attendee);

            Accepted = true;
        }
 public SyncService(
     ICrescoClient crescoClient,
     ICloudService cloudService,
     ILogService logService,
     INetworkService networkService,
     IRepository <InboundShipment> inboundShipmentRepository,
     IRepository <InboundTransfer> inboundTransferRepository,
     IRepository <SalesOrderItem> salesOrderItemRepository,
     IRepository <SalesOrder> salesOrderRepository,
     IRepository <SalesOrderDeliveryString> salesOrderDeliveryRepository,
     IRepository <CustomerInfoUpdateString> customerInfoDeliveryRepository,
     IRepository <SalesOrderUpdateNoticeString> salesOrderUpdateRepository,
     ISalesOrderDeliveryNotificationRepository salesOrderDeliveryNotificationRepository,
     ISalesOrderUpdateNotificationRepository salesOrderUpdateNotificationRepository,
     ICustomerInfoRepository customerInfoRepository,
     IRepository <Branch> branchRepository,
     IRepository <Lot> lotRepository
     )
 {
     _crescoClient                             = crescoClient;
     _cloudService                             = cloudService;
     _logService                               = logService;
     _networkService                           = networkService;
     _salesOrderItemRepository                 = salesOrderItemRepository;
     _inboundShipmentRepository                = inboundShipmentRepository;
     _inboundTransferRepository                = inboundTransferRepository;
     _salesOrderRepository                     = salesOrderRepository;
     _salesOrderDeliveryRepository             = salesOrderDeliveryRepository;
     _salesOrderUpdateRepository               = salesOrderUpdateRepository;
     _customerInfoDeliveryRepository           = customerInfoDeliveryRepository;
     _salesOrderDeliveryNotificationRepository = salesOrderDeliveryNotificationRepository;
     _salesOrderUpateNotificationRepository    = salesOrderUpdateNotificationRepository;
     _customerInfoRepository                   = customerInfoRepository;
     _branchRepository                         = branchRepository;
     _lotRepository                            = lotRepository;
 }
Ejemplo n.º 22
0
        public TaskListViewModel()
        {
            Debug.WriteLine("In TaskListViewModel");
            cloudService = ServiceLocator.Instance.Resolve <ICloudService>();
            Table        = cloudService.GetTable <TodoItem>();

            Title = "Task List";
            items.CollectionChanged += this.OnCollectionChanged;

            RefreshCommand    = new Command(async() => await ExecuteRefreshCommand());
            AddNewItemCommand = new Command(async() => await ExecuteAddNewItemCommand());
            LogoutCommand     = new Command(async() => await ExecuteLogoutCommand());

            // Execute the refresh command
            RefreshCommand.Execute(null);
            MessagingCenter.Subscribe <TaskDetailViewModel>(this, "ItemsChanged", async(sender) =>
            {
                await ExecuteRefreshCommand();
            });
            MessagingCenter.Subscribe <PushToSync>(this, "ItemsChanged", async(sender) =>
            {
                await ExecuteRefreshCommand();
            });
        }
Ejemplo n.º 23
0
 public ArtistController(IPlaylist playlist, IErrorLoggingService logger, ICloudService cloudService, IPlaySettings playSettings)
     : base(cloudService, playlist, logger, playSettings)
 {
 }
Ejemplo n.º 24
0
 public MediaController(ICloudService cloudinaryService, IMediaService mediaService)
 {
     _cloudinaryService = cloudinaryService;
     _mediaService      = mediaService;
 }
Ejemplo n.º 25
0
 public App()
 {
     InitializeComponent();
     CloudService = new AzureCloudService();
     MainPage     = new NavigationPage(new ContactsPage());
 }
        public async Task InitializeAsync <T>(ICloudService <T> cloudService)
        {
            try
            {
                await Task.Run(async() =>
                {
                    _logger.Information($"Begin of {nameof(InitializeAsync)} method.");

                    if (!string.IsNullOrEmpty(
                            await _findInfrastructure.FindInfrastructurePathAsync(cloudService.Provider.Name, cloudService.Infrastructure.Name)))
                    {
                        _logger.Error($"InitializeAsync() failed. Infrastructure with such name is already existed. {GetType().Name}.{nameof(InitializeAsync)}");
                        throw new ApplicationException("InitializeAsync() failed. Infrastructure with such name is already existed.");
                    }

                    var instanceConfig = JsonConvert.SerializeObject(cloudService, Formatting.Indented);
                    var jsonFilePath   = Path.Combine(_findInfrastructure.RootDevice,
                                                      cloudService.Provider.Name,
                                                      cloudService.Infrastructure.Name,
                                                      cloudService.ResourceInstance.Name);

                    Directory.CreateDirectory(jsonFilePath);
                    await File.WriteAllTextAsync(Path.Combine(jsonFilePath, cloudService.ResourceFile.Name),
                                                 instanceConfig);

                    _logger.Information($"End of {nameof(InitializeAsync)} method.");
                });
            }
            catch (ArgumentNullException argumentNullExp)
            {
                _logger.Error(argumentNullExp,
                              $"CloudService argument is null. {GetType().Name}.{nameof(InitializeAsync)}");
                throw;
            }
            catch (ArgumentException argumentExp)
            {
                _logger.Error(argumentExp,
                              $"Error CloudService argument. {GetType().Name}.{nameof(InitializeAsync)}");
                throw;
            }
            catch (JsonSerializationException jsonSerializationExp)
            {
                _logger.Error(jsonSerializationExp,
                              $"Error serializing cloud resource to Json. {GetType().Name}.{nameof(InitializeAsync)}");
                throw;
            }
            catch (DirectoryNotFoundException directoryNotFoundExp)
            {
                _logger.Error(directoryNotFoundExp,
                              $"Infrastructure resource directory is not existed. {GetType().Name}.{nameof(InitializeAsync)}");
                throw;
            }
            catch (IOException ioExp)
            {
                _logger.Error(ioExp,
                              $"Can not access infrastructure resource config file. { GetType().Name}.{ nameof(InitializeAsync)}");
                throw;
            }
            catch (Exception exp)
            {
                _logger.Error(exp,
                              $"Error finding infrastructure resource config file. { GetType().Name}.{ nameof(InitializeAsync)}");
                throw;
            }
        }
 public DefaultAgentContextLoader(ICloudService cloudService)
 {
     _cloudService = cloudService;
 }
Ejemplo n.º 28
0
 public MetricsWorker(ICloudService cloudService, IAnalyzer analyzer, IPluginFactory pluginFactory)
 {
     Analyzer = analyzer;
     PluginFactory = pluginFactory;
 }
Ejemplo n.º 29
0
        public MainPageViewModel(INavigationService navigationService, IApplicationStore applicationStore,
                                 IDeviceService deviceService, IAppDataContext dataContext, ICloudService cloudService)
            : base(navigationService, applicationStore, deviceService)
        {
            _cloudService = cloudService;
            _dataContext  = dataContext;

            Title     = Resources.MainPageTitle;
            TodoItems = new ObservableRangeCollection <TodoItem>();

            AddItemCommand        = new DelegateCommand(OnAddItemCommandExecuted);
            DeleteItemCommand     = new DelegateCommand <TodoItem>(OnDeleteItemCommandExecuted);
            TodoItemTappedCommand = new DelegateCommand <TodoItem>(OnTodoItemTappedCommandExecuted);
        }
 public CloudService(ICloudService cloudService)
 {
     _cloudService = cloudService;
 }
Ejemplo n.º 31
0
 public FirstViewModel(ICloudService pCloudService)
 {
     _cloudService = pCloudService;
 }
Ejemplo n.º 32
0
		internal static AnalyticsResult InternalStartSession(string appId, ICloudService cloudService, string configUrl, string eventUrl){}
Ejemplo n.º 33
0
 public AdultsController(ICloudService iCloudService)
 {
     this.iCloudService = iCloudService;
 }
Ejemplo n.º 34
0
 public SyncWorker(ICloudService cloudService, ICommandFactory commandFactory)
 {
     CloudService = cloudService;
     CommandFactory = commandFactory;
 }
 /// <summary>
 /// Initializes the <see cref="AuthenticationDelegatingHandler{TAccount}" />
 /// </summary>
 public AuthenticationDelegatingHandler(ICloudService <TAccount> cloudService)
 {
     _cloudService = cloudService;
 }
Ejemplo n.º 36
0
 public SensorRepository(ICloudService cloudService)
 {
     _CloudService = cloudService;
 }
Ejemplo n.º 37
0
 public MainPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService,
                          IDeviceService deviceService, IAppDataContext dataContext, ICloudService cloudService)