/// <summary>
/// Uploads the round to the server and clears the current round. Returns null if it could not upload the round correctly.
/// </summary>
public static async Task <RoundModel> CompleteRoundAsync()
{
//Upload the current round to the server.
var request = ServiceResolver.Resolve <IApiRequest>();
// Note the time that the round is ending.
CurrentRound.EndTime = DateTime.UtcNow;
//upload the round to the server.
var completedRound = await request.PostAsync <RoundModel>(
Constants.Endpoints.Rounds, CurrentRound);
if (completedRound?.Id != Guid.Empty)
{
//TODO: Modify the logic here to NOT complete the round if we could not delete
//the file.
//means the upload was a success, so continue with the deletion of the round.
if (await DeleteCurrentRoundAsync())
{
return(completedRound);
}
}
//upload to the server failed, so return null.
return(null);
}
static void Main(string[] args)
{
ServiceResolver resolver = new ServiceResolver();
resolver.ServiceFound += new Network.ZeroConf.ObjectEvent <Network.ZeroConf.IService>(resolver_ServiceFound);
resolver.Resolve("urn:schemas-upnp-org:service:ContentDirectory:1");
//resolver.Resolve("upnp:rootdevice");
//resolver.Resolve("urn:schemas-upnp-org:service:RenderingControl:1");
//IPEndPoint server = new IPEndPoint(IPAddress.Parse("192.168.1.13"), 2869);
//Browse browse = new Browse("http://192.168.1.13:2869/upnphost/udhisapi.dll?control=uuid:a6da68b3-3d15-4655-861f-503e63673e7d+urn:upnp-org:serviceId:ContentDirectory", null);
//XmlDocument didlDoc = new XmlDocument();
//XmlDocument browseResponse = browse.GetResponse().Document;
//didlDoc.LoadXml(browseResponse.DocumentElement.ChildNodes[0].ChildNodes[0].ChildNodes[0].ChildNodes[0].Value);
//XmlNamespaceManager xmlns = new XmlNamespaceManager(didlDoc.NameTable);
//xmlns.AddNamespace("didl", "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/");
//xmlns.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");
//xmlns.AddNamespace("upnp", "urn:schemas-upnp-org:metadata-1-0/upnp/");
//foreach (XmlNode item in didlDoc.SelectNodes("//didl:container/dc:title/text()", xmlns))
//{
// Console.WriteLine(item.Value);
//}
Console.WriteLine("Press enter to exit");
Console.Read();
resolver.ServiceFound -= resolver_ServiceFound;
resolver.Dispose();
}
public void Resolve_InstanceSimpleGeneric()
{
var service = ServiceResolver.Resolve <IInstanceSimpleGeneric <IService> >();
Assert.NotNull(service);
Assert.IsType <SimpleGeneric <IService> >(service);
}
IEnumerable <FilterInfo> GetFilterInfos(
IEnumerable <IServiceAttribute> allAttributes, FilterScope scope)
{
return(_resolver
.Resolve <IFilter>(allAttributes)
.Select(f => new FilterInfo(f, scope)));
}
public void Resolve_Not_Register()
{
var enumerable = ServiceResolver.Resolve <IEnumerable <Transient> >();
Assert.NotNull(enumerable);
Assert.Empty(enumerable);
}
public void ConfigureServices(IServiceCollection services)
{
ServiceConfiguration.Configure(services, Configuration);
DependencyResolver.Resolve(services, Configuration);
ServiceResolver.Resolve(services);
MapperResolver.Resolve(services);
}
public void NonPublic_Property_Inject()
{
var service = (PropertyInjectionService)ServiceResolver.Resolve <IPropertyInjectionService>();
Assert.NotNull(service);
Assert.NotNull(service.InternalLogger);
Assert.Equal(service.InternalLogger, ServiceResolver.Resolve <ILogger>());
}
public void Intercept_OutWithDecimalParamter_Test()
{
var service = ServiceResolver.Resolve <IFakeServiceWithOut>();
decimal num;
Assert.True(service.OutDecimal(out num));
Assert.Equal(1.0M, num);
}
public void Intercept_OutWithIntParamter_Test()
{
var service = ServiceResolver.Resolve <IFakeServiceWithOut>();
int num;
Assert.True(service.OutInt(out num));
Assert.Equal(1, num);
}
public void Resolve_Enumerable()
{
var enumerable = ServiceResolver.Resolve <IEnumerable <IService> >();
Assert.NotNull(enumerable);
Assert.Equal(3, enumerable.Count());
Assert.NotEqual(enumerable, ServiceResolver.Resolve <IEnumerable <IService> >());
}
public void Resolve_ManyEnumerable()
{
var many = ServiceResolver.Resolve <IManyEnumerable <IService> >();
Assert.NotNull(many);
Assert.Equal(3, many.Count());
Assert.NotEqual(many, ServiceResolver.Resolve <IManyEnumerable <IService> >());
}
public void Equal()
{
var userService1 = ServiceResolver.Resolve <IUserService>();
var userService2 = ServiceResolver.Resolve <IUserService>();
Assert.NotEqual(userService1, userService2);
Assert.Equal(userService1.Repository, userService2.Repository);
}
public void Constructor_Inject()
{
var userService = ServiceResolver.Resolve <IUserService>();
Assert.NotNull(userService);
Assert.NotNull(userService.Repository);
Assert.NotNull(userService.Logger);
}
public ConfigurationViewModel()
{
this.Crumbs.Add(new Shared.Controls.BreadcrumbItemModel("Settings"));
settings = ServiceResolver.Resolve <ISettings>();
apiHost = settings.GetValue <string>(Constants.APIHostConfigKey);
Save = new AsyncCommand(async(obj) => await this.SaveCommand(), CanSave);
TestConnection = new AsyncCommand(async(obj) => await this.TestApiConnection(), CanTest);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionString = ServiceResolver.Resolve <IConfiguration>().GetConnectionString("TodoAppDb");
if (!optionsBuilder.IsConfigured)
{
optionsBuilder.UseSqlite(connectionString);
}
}
public void Resolve_IServiceProvider()
{
var serviceResolver = ServiceResolver.Resolve <IServiceProvider>();
Assert.Equal(ServiceResolver, serviceResolver);
using (var scopedServiceResolver = ServiceResolver.CreateScope())
{
Assert.Equal(scopedServiceResolver, scopedServiceResolver.Resolve <IServiceProvider>());
}
}
public void Dispose()
{
var scopedResolver = ServiceResolver.CreateScope();
var singleton = ServiceResolver.Resolve <ISingleton>();
scopedResolver.Dispose();
Assert.False(singleton.IsDisposed);
ServiceResolver.Dispose();
Assert.True(singleton.IsDisposed);
}
public void Init()
{
_LoggingService = ServiceResolver.Resolve <LoggingService>();
_PreferenceRepository = ServiceResolver.Resolve <PreferenceRepository>();
_ExecutionRepository = ServiceResolver.Resolve <ExecutionRepository>();
_ActionRepository = ServiceResolver.Resolve <ActionRepository>();
_PlaneRepository = ServiceResolver.Resolve <PlaneRepository>();
_WcfService = ServiceResolver.Resolve <WcfService>();
_FileService = ServiceResolver.Resolve <FileService>();
}
protected virtual TService ResolveService <TService>()
{
var svc = ServiceResolver.Resolve <TService>();
if (svc == null)
{
throw new InvalidOperationException($"An instance of {nameof(TService)} could not be resoved.");
}
return(svc);
}
public async Task <IActionResult> CreateContact(ContactCreateRequest request)
{
var captchaService = ServiceResolver.Resolve <ICaptchaValidatorService>();
var captchaCheck = await captchaService.ValidateToken(request.Token);
if (!string.IsNullOrEmpty(captchaCheck))
{
return(BadRequest(new List <ValidationResult> {
new(captchaCheck)
}));
public void Get_Value()
{
var accessor1 = ServiceResolver.Resolve <ITransientServiceAccessor <ITransient> >();
Assert.NotEqual(accessor1.Value, accessor1.Value);
Assert.NotEqual(accessor1.Value, ServiceResolver.Resolve <ITransient>());
using (var scope = ServiceResolver.CreateScope())
{
var accessor2 = scope.Resolve <ITransientServiceAccessor <ITransient> >();
Assert.Equal(accessor1, accessor2);
Assert.NotEqual(accessor1.Value, accessor2.Value);
}
}
public void Equal()
{
var transient1 = ServiceResolver.Resolve <ITransient>();
var transient2 = ServiceResolver.Resolve <ITransient>();
using (var scopedResolver = ServiceResolver.CreateScope())
{
var transient3 = ServiceResolver.Resolve <ITransient>();
Assert.NotEqual(transient1, transient2);
Assert.NotEqual(transient2, transient3);
Assert.NotEqual(transient1, transient3);
}
}
static void Main(string[] args)
{
HeimdallConfiguration.Instance.Database.UseSQLServer("localhost", "sa", "81547686", "AbcInfo");
HeimdallConfiguration.Instance.UseMyCustomEncryptor(new MeuEncryptor());
string crypto = HeimdallConfiguration.Instance.EncryptService.Encrypt("Meu nome");
string decrypto = HeimdallConfiguration.Instance.EncryptService.Decript("Meu nome");
Console.WriteLine(crypto);
Console.WriteLine(decrypto);
IOrganizationService service = ServiceResolver <IOrganizationService> .Resolve();
Console.ReadKey();
}
/// <summary>
/// Costructor
/// </summary>
public SemperPrecisStageTrackerContext()
{
var configuration = ServiceResolver.Resolve <IConfiguration>();
const string SqlDbConnectionStringName = "SqlDb";
var sqlSetting = configuration.GetConnectionString(SqlDbConnectionStringName);
if (sqlSetting == null)
{
throw new InvalidProgramException("Connection string for database with " +
$"name '{SqlDbConnectionStringName}' cannot be found");
}
ConnectionString = sqlSetting;
//ConnectionString = sqlSetting.ConnectionString;
}
/// <summary>
/// Starts a new round. Populates the basic round info based on the settings and time.
/// </summary>
/// <returns>The newly started round.</returns>
public static RoundModel StartNewRound()
{
if (Singleton != null)
{
return(null);
}
var settings = ServiceResolver.Resolve <ISettings>();
return(Singleton = new RoundModel()
{
StartTime = DateTime.UtcNow,
AssignedTo = settings.GetValue <string>(Constants.UserDomainName)
});
}
private async void SaveInput(ReadingInputViewModel newData)
{
if (this.input.ItemId == Guid.Empty)
{
return;
}
var io = ServiceResolver.Resolve <IFileHandler>();
var existingReading = ReadingManager.Find(newData.ItemId);
//reading already exists or was just created, so just update the values.
var item = this.station.Items.FirstOrDefault(i => i.Id == newData.ItemId);
if (newData.IsBooleanInput)
{
existingReading.Value = newData.BooleanValue.ToString();
}
else
{
existingReading.Value = newData.StringValue;
}
existingReading.Comments = newData.Comments;
existingReading.TimeTaken = DateTime.UtcNow;
// Now validate the users input
var validator = ComparisonTypeViewModel.Locate(newData.InputType);
if (validator.UsesOneInput)
{
existingReading.IsOutOfSpec = validator.Validate(
value: existingReading.Value,
max: item.Specification.UpperBound) == false;
}
else
{
existingReading.IsOutOfSpec = validator.Validate(
value: existingReading.Value,
min: item.Specification.LowerBound,
max: item.Specification.UpperBound) == false;
}
//finally, write out the result to file so that way it doesn't get lost.
item.CurrentReading = existingReading;
this.ListModel.SetSelectedAsVisited();
await ReadingManager.SaveReadingsToDiskAsync();
//place binding for completed items here. probably.
}
public void Resolve_Enumerable_Lifetime()
{
var many = ServiceResolver.Resolve <IEnumerable <IService> >().ToArray();
var many1 = ServiceResolver.Resolve <IEnumerable <IService> >().ToArray();
Assert.NotEqual(many[0], many1[0]);
Assert.Equal(many[1], many1[1]);
Assert.Equal(many[2], many1[2]);
using (var scope = ServiceResolver.CreateScope())
{
var many2 = scope.Resolve <IEnumerable <IService> >().ToArray();
Assert.NotEqual(many[0], many2[0]);
Assert.Equal(many[1], many2[1]);
Assert.NotEqual(many[2], many2[2]);
}
}
public void Equal()
{
var singleton1 = ServiceResolver.Resolve <ISingleton>();
using (var scopedResolver = ServiceResolver.CreateScope())
{
var singleton2 = scopedResolver.Resolve <ISingleton>();
using (var scopedResolver1 = ServiceResolver.CreateScope())
{
var singleton3 = scopedResolver1.Resolve <ISingleton>();
Assert.Equal(singleton1, singleton2);
Assert.Equal(singleton1, singleton3);
Assert.Equal(singleton2, singleton3);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dataSession">Active data session</param>
public AuthenticationServiceLayer(IDataSession dataSession)
: base(dataSession)
{
//Inizializzazioni
_userRepository = dataSession.ResolveRepository <IShooterRepository>();
_permissionRepository = dataSession.ResolveRepository <IPermissionRepository>();
_permissionRoleRepository = dataSession.ResolveRepository <IPermissionsRoleRepository>();
_roleRepository = dataSession.ResolveRepository <IRoleRepository>();
_userRoleRepository = dataSession.ResolveRepository <IUserRoleRepository>();
_userPermissionRepository = dataSession.ResolveRepository <IUserPermissionRepository>();
_permissionGroupRepository = dataSession.ResolveRepository <IPermissionGroupRepository>();
_userPermissionGroupRepository = dataSession.ResolveRepository <IUserPermissionGroupRepository>();
_permissionGroupRoleRepository = dataSession.ResolveRepository <IPermissionGroupRoleRepository>();
_identityClient = ServiceResolver.Resolve <IIdentityClient>();
_cache = ServiceResolver.Resolve <ISemperPrecisMemoryCache>();
}
public void Equal()
{
var scoped1 = ServiceResolver.Resolve <IScoped>();
using (var scopedResolver = ServiceResolver.CreateScope())
{
var scoped2 = scopedResolver.Resolve <IScoped>();
var scoped3 = scopedResolver.Resolve <IScoped>();
var scoped4 = ServiceResolver.Resolve <IScoped>();
Assert.Equal(scoped1, scoped4);
Assert.Equal(scoped2, scoped3);
Assert.NotEqual(scoped1, scoped2);
Assert.NotEqual(scoped1, scoped3);
Assert.NotEqual(scoped2, scoped4);
Assert.NotEqual(scoped3, scoped4);
}
}
