public Services(
IEntryService entryService,
IUserService userService,
IConfigService configService,
IMessageService messageService,
ICloudService cloudService)
{
Entry = entryService;
User = userService;
Config = configService;
Message = messageService;
Cloud = cloudService;
}
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();
}
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);
}
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;
}
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));
}
}
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;
}
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;
}
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;
}
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;
}
}
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!");
}
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;
}
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>();
}
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;
}
}
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);
}
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);
}
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());
}
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
}
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;
}
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();
});
}
public ArtistController(IPlaylist playlist, IErrorLoggingService logger, ICloudService cloudService, IPlaySettings playSettings)
: base(cloudService, playlist, logger, playSettings)
{
}
public MediaController(ICloudService cloudinaryService, IMediaService mediaService)
{
_cloudinaryService = cloudinaryService;
_mediaService = mediaService;
}
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;
}
public MetricsWorker(ICloudService cloudService, IAnalyzer analyzer, IPluginFactory pluginFactory)
{
Analyzer = analyzer;
PluginFactory = pluginFactory;
}
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;
}
public FirstViewModel(ICloudService pCloudService)
{
_cloudService = pCloudService;
}
internal static AnalyticsResult InternalStartSession(string appId, ICloudService cloudService, string configUrl, string eventUrl){}
public AdultsController(ICloudService iCloudService)
{
this.iCloudService = iCloudService;
}
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;
}
public SensorRepository(ICloudService cloudService)
{
_CloudService = cloudService;
}
public MainPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService,
IDeviceService deviceService, IAppDataContext dataContext, ICloudService cloudService)
