private ProviderService CreateProviderService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ProviderService(userId);
return(service);
}
/// <summary>
/// This method starts the service.
/// </summary>
static void Main(string[] args)
{
try {
ServiceConnection connection = Factory.Provider.ConnectionManager();
connection.OnCreateProvider = () => new IBInterface();
if (args.Length > 0)
{
// Connection port provided on command line.
ProviderService commandLine = Factory.Utility.CommandLineProcess();
commandLine.Connection = connection;
commandLine.Run(args);
}
else
{
// Connection port set via ServicePort in app.config
ProviderService service = Factory.Utility.WindowsService();
service.Connection = connection;
service.Run(args);
}
} catch (Exception ex) {
string exception = ex.GetType() + ": " + ex.Message + Environment.NewLine + ex.StackTrace;
System.Diagnostics.Debug.WriteLine(exception);
Console.WriteLine(exception);
Environment.Exit(1);
}
}
public async Task <IActionResult> TestProviderAsync(string name, [FromBody] IDictionary <string, string> config)
{
var providerType = ProviderService.GetProvider(name);
if (providerType == null)
{
return(NotFound());
}
var provider = (IMetricValueProvider)Activator.CreateInstance(providerType);
var providerProperties = providerType.GetProperties();
foreach (var prop in providerProperties)
{
if (config.TryGetValue(prop.Name, out var value))
{
prop.SetValue(provider, value);
}
}
var val = await provider.GetValueAsync();
return(Ok(val));
}
public async Task <ActionResult> ProviderDelete(Guid id)
{
var providerService = new ProviderService();
await providerService.RemoveProvider(id);
return(RedirectToAction(nameof(ProviderList)));
}
public async Task Then_Gets_The_Provider_From_The_Repository_With_Location_Information_And(
int ukPrn,
int standardId,
double lat,
double lon,
string sectorSubjectArea,
Guid shortlistUserId,
Domain.Entities.ProviderWithStandardAndLocation provider,
[Frozen] Mock <IProviderRepository> repository,
ProviderService service)
{
//Arrange
repository.Setup(x => x.GetProviderByStandardIdAndLocation(ukPrn, standardId, shortlistUserId, lat, lon, sectorSubjectArea)).ReturnsAsync(new List <Domain.Entities.ProviderWithStandardAndLocation> {
provider
});
//Act
var actual = await service.GetProviderByUkprnAndStandard(ukPrn, standardId, lat, lon, sectorSubjectArea, shortlistUserId);
//Assert
repository.Verify(x => x.GetProviderByStandardIdAndLocation(ukPrn, standardId, shortlistUserId, lat, lon, sectorSubjectArea), Times.Once);
actual.Should().NotBeNull();
actual.Ukprn.Should().Be(provider.Ukprn);
actual.Name.Should().Be(provider.Name);
actual.TradingName.Should().Be(provider.TradingName);
actual.MarketingInfo.Should().Be(provider.MarketingInfo);
}
/// <summary>
/// Builds list of Providers
/// </summary>
/// <remarks>
/// This method will attempt to load the list of
/// providers from the json file hosted on the ace
/// config server and if it cannot then it will append
/// only the Custom option to the drop-down menu.
/// </remarks>
/// <returns>Task</returns>
private async Task UpdateProvidersList()
{
bool status = await LoadJsonProvidersAsync();
if (status)
{
return;
}
ProviderService.AddProvider(new VATRPServiceProvider()
{
Label = "Custom",
Address = null
});
/*
* string[] labels = { "Sorenson", "Purple", "ZVRS", "Convo", "Global" };
* foreach (var label in labels)
* {
* if (ProviderService.FindProvider(label) == null)
* ProviderService.AddProvider(new VATRPServiceProvider()
* {
* Label = label,
* Address = null
* });
* }
*/
}
public ProviderController(
ProviderService service,
IMapper mapper)
{
this.service = service;
this.mapper = mapper;
}
public When_ProviderService_Is_Called_To_Create_Provider()
{
var httpContextAccessor = Substitute.For <IHttpContextAccessor>();
var config = new MapperConfiguration(c =>
{
c.AddMaps(typeof(ProviderMapper).Assembly);
c.ConstructServicesUsing(type =>
type.Name.Contains("LoggedInUserEmailResolver") ?
new LoggedInUserEmailResolver <CreateProviderDetailViewModel, Domain.Models.Provider>(httpContextAccessor) :
type.Name.Contains("LoggedInUserNameResolver") ?
(object)new LoggedInUserNameResolver <CreateProviderDetailViewModel, Domain.Models.Provider>(httpContextAccessor) :
type.Name.Contains("UtcNowResolver") ?
new UtcNowResolver <CreateProviderDetailViewModel, Domain.Models.Provider>(new DateTimeProvider()) :
null);
});
var mapper = new Mapper(config);
_repository = Substitute.For <IRepository <Domain.Models.Provider> >();
var referenceRepository = Substitute.For <IRepository <ProviderReference> >();
_repository.CreateAsync(Arg.Any <Domain.Models.Provider>())
.Returns(ProviderId);
var providerService = new ProviderService(mapper, _repository, referenceRepository);
var viewModel = new CreateProviderDetailViewModel
{
UkPrn = 123,
Name = "ProviderName",
DisplayName = "Display name"
};
_result = providerService.CreateProviderAsync(viewModel).GetAwaiter().GetResult();
}
public ActionResult Details(int id)
{
var service = new ProviderService();
var model = service.GetProviderById(id);
return(View(model));
}
public async Task <IActionResult> Insert(ProviderInsertViewModel viewmodel)
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ProviderInsertViewModel, ProviderDTO>();
});
IMapper mapper = configuration.CreateMapper();
// new SERService().GetSERByID(4);
//Transforma o ClienteInsertViewModel em um ClienteDTO
ProviderDTO dto = mapper.Map <ProviderDTO>(viewmodel);
ProviderService svc = new ProviderService();
try
{
await svc.Insert(dto);
return(RedirectToAction("Index", "Category"));
}
catch (Exception ex)
{
ViewBag.Erros = ex.Message;
}
return(View());
}
public ProductController(ProductService service, IMapper mapper, ProductTypeService productTypeService, ProviderService providerService)
{
this.service = service;
this.mapper = mapper;
this.productTypeService = productTypeService;
this.providerService = providerService;
}
/// <summary>
/// This method starts the service.
/// </summary>
static void Main(string[] args)
{
try {
Console.WriteLine("Command line: " + string.Join(" ", args));
ServiceConnection connection = Factory.Provider.ConnectionManager();
connection.OnCreateProvider = () => new MBTProvider(connection.Config);
if (args.Length > 0)
{
// Connection port provided on command line.
ProviderService commandLine = Factory.Utility.CommandLineProcess();
commandLine.Connection = connection;
commandLine.Run(args);
}
else
{
// Connection port set via ServicePort in app.config
ProviderService service = Factory.Utility.WindowsService();
service.Connection = connection;
service.Run(args);
}
} catch (Exception ex) {
string exception = ex.ToString();
System.Diagnostics.Debug.WriteLine(exception);
Console.WriteLine(exception);
Environment.Exit(1);
}
}
/// <summary>
/// Register providers from user settings, where they were previously saved.
/// </summary>
public async Task RestoreProviders()
{
// Load available IProvider types into memory
if (ProviderService.Available.Count == 0)
{
ProviderService.LoadProviders();
}
var tasks = new Dictionary <string, Task <bool> >();
// ToList() is needed because the original Dictionary is changing while we iterating
SettingsService.Current.SafeProviders
.ToList()
.ForEach(p => tasks[p.Key] = ProviderService.RegisterProvider(
ProviderService.GetProviderById(p.Value.Id), p.Key, p.Value.State, false));
// Wait for tasks to finish and remove unloaded providers
foreach (var task in tasks)
{
if (!ProviderService.Loaded.ContainsKey(task.Key) && !await task.Value)
{
ToastService.Create(string.Format(Resources.ProviderRegistrationFailed, task.Key));
ProviderService.ClearProvider(task.Key);
}
}
}
public SearchProviderOrderViewModel()
{
providerService = new ProviderService();
orderService = new OrderService();
Providers = new ObservableCollection <Provider>();
PressButton = PROVEEDOR;
}
public ActionResult Index()
{
var service = new ProviderService();
var model = service.GetProviders();
return(View(model));
}
public bool AltaEvento(Evento evento)
{
var _providerService = new ProviderService();
var fechaParseada = String.Format("{0:yyyy-MM-dd HH:mm:ss}", evento.Fecha);
return(_providerService.ExecuteNonQuery(String.Format(@"INSERT INTO eventos (the_geom, fecha, denunciante, victimas, detalle, tipodelito, direccion) VALUES (ST_GeomFromText('POINT({0} {1})', 4326), '{2}', '{3}', '{4}', '{5}', '{6}', '{7}')", evento.Longitud, evento.Latitud, fechaParseada, evento.Denunciante, evento.Victimas, evento.Detalle, evento.TipoDelito, evento.Direccion)));
}
private IEnumerable<Provider> GetProviders()
{
var result = new ProviderService().GetProvidersAsync().Result;
var list = result.ToList();
Debug.WriteLine("providersl" + list.Count());
return list;
}
public ProvidersController()
{
Context = AppService.Current.DataContextV2;
ProviderRepository = new ProviderRepository();
ProviderService = new ProviderService();
HoursRepository = new HoursRepo();
}
public ServicesManager(DataManager dataManager)
{
_dataManager = dataManager;
Comings = new ComingService(_dataManager);
Writeoffs = new WriteoffService(_dataManager);
Products = new ProductService(_dataManager);
Providers = new ProviderService(_dataManager);
}
private ProviderService CreateServiceMock()
{
_repositoryMock = new Mock <IProviderRepository>();
_repository = _repositoryMock.Object;
var service = new ProviderService(_repository, mapper);
return(service);
}
public async Task ShouldCallTheSelectAsyncMethod_WhenGetAllMethodIsCalled()
{
ProviderService service = CreateServiceMock();
var result = await service.GetAll();
_repositoryMock.Verify(repo => repo.SelectAsync(), Times.Once());
}
public IHttpActionResult GetProviderFromName([FromBody] string nameJson)
{
var dataJson = EncryptHelper.Base64Decode(nameJson);
ProviderService providerService = new ProviderService();
var data = providerService.GetProviderFromName(dataJson);
return(Ok(data));
}
public IProviderService Build()
{
var provider = new ProviderService(_providerReadRepository, _providerSiteReadRepository,
_vacancyOwnerRelationshipReadRepository, _vacancyOwnerRelationshipWriteRepository, _logService,
_employerService, _providerWriteRepository, _providerSiteWriteRepository);
return(provider);
}
public IActionResult GetProviders()
{
var descriptors = ProviderService.GetProviders()
.Select(kv => MetadataService.GetMetadata(kv.Value))
.ToList();
return(Ok(descriptors));
}
public static IProviderService GetService()
{
var logger = Microsoft.Extensions.Logging.Abstractions.NullLogger <ProviderService> .Instance;
var settings = TestConfig.GetSettings <ProviderServiceSettings>("ProviderServiceSettings");
IProviderService service = new ProviderService(logger, new System.Net.Http.HttpClient(), Options.Create(settings));
return(service);
}
protected ProviderCommandCoreTests(ProviderService providerService, ITestOutputHelper outputHelper)
{
ProviderService = providerService ?? throw new ArgumentNullException(nameof(providerService));
Logger = XUnitLogger.Create(GetType(), outputHelper);
Test = outputHelper.GetTest();
configuration = new Lazy <IConfiguration>(() => BuildConfiguration(new ConfigurationBuilder()));
}
private async Task <List <Provider> > InitializeDataAsync()
{
var ProviderService = new ProviderService();
providerList = await ProviderService.GetAllProviders();
return(providerList);
}
public ActionResult DeleteProvider(int id)
{
var service = new ProviderService();
service.DeleteProvider(id);
TempData["SaveResult"] = "Provider deleted.";
return(RedirectToAction("Index"));
}
public void Given_Setup_MockProviderService__Then_Access_MockProviderService_Not_Null()
{
var providerService = new ProviderService("consumer", "provider", configPath);
providerService.StartMockService();
Assert.IsNotNull(providerService.MockProviderService);
}
static void Main(string[] args)
{
Serilog.ILogger logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
IFeatureToggle featureToggle = new FeatureToggles();
//string specificationId = "a1fe8998-406b-44b8-92c7-502a560e7b6e";
////string providerId = "10027545";
//string providerId = "10004758";
string specificationId = "b1952bc1-4ed9-4ae1-b29d-c72d8d22e830";
//string providerId = "10027545";
string providerId = "10063088";
IConfigurationRoot config = ConfigHelper.AddConfig();
EngineSettings engineSettings = new EngineSettings();
CosmosDbSettings dbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", dbSettings);
dbSettings.CollectionName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(dbSettings);
IProviderSourceDatasetsRepository providerSourceDatasetsRepository = new ProviderSourceDatasetsRepository(calcsCosmosRepostory, engineSettings);
RedisSettings redisSettings = new RedisSettings();
config.Bind("redisSettings", redisSettings);
ICacheProvider cacheProvider = new StackExchangeRedisClientCacheProvider(redisSettings);
ApiOptions apiOptions = new ApiOptions();
config.Bind("resultsClient", apiOptions);
ICorrelationIdProvider correlationIdProvider = new CorrelationIdProvider();
IResultsApiClientProxy resultsApi = new ResultsApiProxy(apiOptions, logger, correlationIdProvider);
IMapper mapper = new MapperConfiguration(c =>
{
c.AddProfile <ProviderMappingProfile>();
}).CreateMapper();
ProviderService providerService = new ProviderService(cacheProvider, resultsApi, mapper);
FilesystemCacheProviderService filesystemCacheProviderService = new FilesystemCacheProviderService(providerService);
AllocationModelDebugRunner debugger = new AllocationModelDebugRunner(logger, featureToggle, providerSourceDatasetsRepository, filesystemCacheProviderService);
(IEnumerable <Models.Results.CalculationResult> calculationResults, long ms) = debugger.Execute(specificationId, providerId).Result;
CalculationRunSummaryGenerator summaryGenerator = new CalculationRunSummaryGenerator();
summaryGenerator.GenerateSummary(calculationResults, ms, specificationId, providerId);
}
public QueryResultSet<ServiceResponse> GetAllServicesByProviderId(int providerId, string st)
{
int serviceStatus = -1;
Provider provider = null;
ProviderResponse providerResponse = null;
List<ServiceDetails> serviceDetailsList = null;
List<ServiceResponse> serviceResponseList = new List<ServiceResponse>();
QueryResultSet<ServiceResponse> resultSet = new QueryResultSet<ServiceResponse>();
try
{
if (string.IsNullOrEmpty(st))
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Session Token is empty" });
resultSet.InfoMessages = err;
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
return resultSet;
}
if (!SessionHelper.IsValidSession(st))
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Invalid Session Token" });
resultSet.InfoMessages = err;
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
return resultSet;
}
if(providerId <=0)
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Provider id should be greather than zero" });
resultSet.InfoMessages = err;
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
return resultSet;
}
using (var owlsService = new OwlsService())
{
provider = new ProviderService().GetSingle(x => x.Id == providerId);
if (provider != null)
{
providerResponse = new ProviderService().ToModelResponse(provider);
serviceStatus = Convert.ToInt32(Enums.ServiceStatus.Active);
var serviceItems = owlsService.dbContext.Service.Where(x => x.ProviderId == providerId && x.Status == serviceStatus).ToList();
if (serviceItems.Count > 0)
{
serviceDetailsList = new List<ServiceDetails>();
foreach (Service service in serviceItems)
{
serviceDetailsList = new ServiceDetailService().dbContext.ServiceDetails.Where(x => x.ServiceId == service.Id && x.Status == serviceStatus).ToList();
var serviceResponse = owlsService.ToModelResponse(service, provider, serviceDetailsList);
if (serviceResponse != null)
{
serviceResponseList.Add(serviceResponse);
}
}
resultSet.IsResult = true;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = serviceResponseList;
}
else
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Service list is empty" });
resultSet.InfoMessages = err;
resultSet.IsResult = false;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = null;
}
}
else
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Provider not found" });
resultSet.InfoMessages = err;
resultSet.IsResult = false;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = null;
resultSet.ResultSet = null;
}
}
}
catch (Exception ex)
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.ErrorMessage), Text = ex.Message });
resultSet.ErrorMessages = err;
resultSet.IsResult = false;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = null;
}
return resultSet;
}
protected void btnSave_Click(object sender, EventArgs e)
{
Data.Provider provider = null;
if (editMode == false)
{
provider = new Data.Provider();
provider.ProviderId = System.Guid.NewGuid().ToString();
}
else
{
provider = GetProvider();
}
provider.Name = tbProviderName.Text;
provider.Phone = tbTelephone.Text;
provider.Fax = tbFax.Text;
provider.Address = tbAddress.Text;
provider.City = tbCity.Text;
provider.State = "MS";
provider.Zip = tbZipCode.Text;
provider.Email = tbEmail.Text;
foreach (ProviderService providerService in provider.ProviderServices.ToList())
{
DatabaseContext.ProviderServices.DeleteObject(providerService);
DatabaseContext.SaveChanges();
}
string leftHandItems = ServicesNeededLeftHidden.Value;
List<DataItem> leftHandItemSerialize = (List<DataItem>)Newtonsoft.Json.JsonConvert.DeserializeObject(leftHandItems, typeof(List<DataItem>));
foreach (DataItem item in leftHandItemSerialize)
{
ProviderService service = new ProviderService
{
ProviderServiceId = System.Guid.NewGuid().ToString(),
ServiceId = item.value
};
provider.ProviderServices.Add(service);
}
foreach (ProviderCounty providerCounty in provider.ProviderCounties.ToList())
{
DatabaseContext.ProviderCounties.DeleteObject(providerCounty);
DatabaseContext.SaveChanges();
}
string leftHandCountyItems = CountyLeftHidden.Value;
List<DataItem> leftHandItemSerializeCounty = (List<DataItem>)Newtonsoft.Json.JsonConvert.DeserializeObject(leftHandCountyItems, typeof(List<DataItem>));
foreach (DataItem item in leftHandItemSerializeCounty)
{
ProviderCounty county = new ProviderCounty
{
ProviderCountiesId = System.Guid.NewGuid().ToString(),
County = item.value
};
provider.ProviderCounties.Add(county);
}
if (editMode == false)
{
provider.CreationTime = DateTime.Now;
provider.CreationUser = LoggedInUser.UserName;
DatabaseContext.AddToProviders(provider);
}
else
{
provider.LastUpdateUser = LoggedInUser.UserName;
provider.LastUpdateTime = DateTime.Now;
}
DatabaseContext.SaveChanges();
Response.Redirect("~/Administer/ManageProviders.aspx");
}
