public void HandleLine(string csvLine)
{
var registration = new Registration(csvLine);
Registrations.Add(registration);
var club = Clubs.FirstOrDefault(c => c.Name == registration.Club) ?? new Club(registration.Club);
club.Registration.Add(registration);
Clubs.Add(club);
/*var registration = new Registration(csvLine);
* Registrations.Add(registration);
*
* Club clubSearchRestult = null;
*
* foreach (var club in Clubs)
* {
* if (club.Name == registration.Club)
* {
* clubSearchRestult = club.Name;
* break;
* }
* }*/
}
/// <summary>
/// Register a Type for injection.
/// </summary>
/// <typeparam name="TClass">Type to register.</typeparam>
public void Register <TClass>() where TClass : class
{
if (Registrations.Values.Contains(typeof(TClass)))
{
throw new RegistrationException(typeof(TClass).ToString() + "is already registered.");
}
Registrations.Add(typeof(TClass), typeof(TClass));
}
/// <summary>
/// Registers the builder as a generator for resolving the given type.
/// Throws if a builder is already registered for the type.
/// </summary>
/// <typeparam name="T">The type that shall be registered.</typeparam>
/// <param name="builder">The function to be executed when the given type is resolved.</param>
/// <returns>The container.</returns>
/// <exception cref="DuplicateRegistrationException">Thrown when a Registration was already present for the type</exception>
public IDependencyContainer Register <T>(Func <IDependencyContainer, T> builder)
{
if (IsRegisteredLocal <T>())
{
throw new DuplicateRegistrationException(typeof(T));
}
Registrations.Add(typeof(T), _ => builder(_));
return(this);
}
public void RegisterProvider <T>() where T : IDatabaseConnectionProvider, new()
{
var provider = new T();
if (Registrations.Any(t => t.Name == provider.Name))
{
throw new ArgumentException($"Provider {provider.Name} is already registered");
}
Registrations.Add(provider);
}
public void HandleLine(string line)
{
var fields = line.Split(',');
var startNumber = fields[0].Trim('"');
var name = fields[1].Trim('"');
var club = fields[2].Trim('"');
var nationality = fields[3].Trim('"');
var @group = fields[4].Trim('"');
var @class = fields[5].Trim('"');
Registrations.Add(new Registration(startNumber, name, club, nationality, @group, @class));
}
public void Register(Type service, Type implementation)
{
if (!Registrations.ContainsKey(service))
{
Registrations.Add(service, new List <Type> {
implementation
});
}
else
{
Registrations[service].Add(implementation);
}
}
public virtual Dojo Register(MartialArtist martialArtist)
{
var registration = new Registration {
StudentId = martialArtist.Id, Active = true, DojoId = Id
};
if (Registrations.Any(r => r.StudentId == martialArtist.Id))
{
throw new StudentAlreadyRegisteredException(this, martialArtist);
}
Registrations.Add(registration);
DomainEvents.Raise(new StudentRegistered(Id, martialArtist.Id, DateTime.Now));
return(this);
}
///<summary>
/// Adds the registration.
/// </summary>
/// <param name="reg">The reg.</param>
public void AddRegistration(PatientRegistration reg)
{
if (Registrations == null)
{
Registrations = new List <PatientRegistration>();
}
// If the fees is not already in the list
if (!Registrations.Any(x => x.PrimaryKey == reg.PrimaryKey))
{
Registrations.Add(reg);
reg.Patient = this;
}
}
private void Apply(RobotUnregistered e)
{
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
throw new InvalidOperationException("Robot is not already registered");
}
latestRegistration.Apply(
registration => { Registrations = Registrations.Add(RobotRegistration.Unregistration.Instance); },
unregistration => throw new InvalidOperationException("Robot is not already registered")
);
}
public async Task AddRegistration(Event @event, Participant participant)
{
Registration registration = new Registration(GetUniqueId(), participant.UserName, @event.Id);
bool ok = await _registrationPersistence.Post(registration);
if (ok)
{
Registrations.Add(registration);
RegistrationDictionary[@event].Add(participant);
}
else
{
throw new BaseException("Add regi fail");
}
}
public void HandleLine(string csvLine)
{
var registration = new Registration(csvLine);
Registrations.Add(registration);
var club = Clubs.FirstOrDefault(c => c.Name == registration.Club);
if (club == null)
{
club = new Club(registration.Club);
Clubs.Add(club);
}
club.Add(registration);
}
private void ImportRegistrations(RobotImported e)
{
void AddRegistration(Guid endUserId)
{
var newRegistration = new RobotRegistration.Registration(this, e, endUserId);
Registrations = Registrations.Add(newRegistration);
}
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
if (e.Entity.C2RurEnduserValue != null)
{
AddRegistration(e.Entity.C2RurEnduserValue.Value);
}
}
else
{
latestRegistration.Apply(
registration =>
{
if (registration.EndUserId.Value == e.Entity.C2RurEnduserValue)
{
registration.Apply(e);
}
else if (e.Entity.C2RurEnduserValue.HasValue)
{
AddRegistration(e.Entity.C2RurEnduserValue.Value);
}
else
{
Registrations = Registrations.Add(RobotRegistration.Unregistration.Instance);
}
},
unregistration =>
{
if (e.Entity.C2RurEnduserValue.HasValue)
{
AddRegistration(e.Entity.C2RurEnduserValue.Value);
}
}
);
}
}
public void lineHandler(string line) //henter inn en og en linje i teksten og sender de til registration (hvor den splittes) og legges i lista.
{
var registration = new Registration(line);
Registrations.Add(registration);
var club = Clubs.FirstOrDefault(c => c.Name == registration.Club);
if (club == null)
{
club = new Club(registration.Club);
Clubs.Add(club);
}
club.Add(registration);
/*var name*/
}
internal bool AddRegistration()
{
bool res = false;
if ((Registration.Ref != 0))
{
if (Registration.Create())
{
if (Registration.GetById())
{
Registrations.Add(Registration);
res = true;
}
}
}
return(res);
}
private List <ActionRegistration> Get(Type t)
{
if (!Registrations.ContainsKey(t))
{
Registrations.Add(t, new List <ActionRegistration>());
}
var l = Registrations[t];
if (l != null)
{
return(l);
}
l = new List <ActionRegistration>();
Registrations[t] = l;
return(l);
}
public void AddBinding(ServiceBinding serviceBinding)
{
SinglyLinkedListNode <Type>?currentNode = serviceBinding.ServiceTypes;
while (currentNode != null)
{
Type type = currentNode.Value;
if (!Registrations.TryGetValue(type, out Registration registration))
{
registration = new Registration(serviceBinding);
Registrations.Add(type, registration);
}
else
{
registration.AddBinding(serviceBinding);
}
currentNode = currentNode.Next;
}
}
public void AddBinding(Binding binding)
{
SinglyLinkedListNode <Type>?currentNode = binding.BindingMetadata.DependencyTypes;
while (currentNode != null)
{
Type type = currentNode.Value;
if (!Registrations.TryGetValue(type, out Registration registration))
{
registration = new Registration(type, binding);
Registrations.Add(type, registration);
}
else
{
registration.AddBinding(binding);
}
currentNode = currentNode.Next;
}
}
/// <inheritdoc/>
public async Task <bool> RegisterAsync(IBackgroundTask task)
{
var backgroundStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (backgroundStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy ||
backgroundStatus == BackgroundAccessStatus.AlwaysAllowed)
{
var builder = new BackgroundTaskBuilder();
builder.IsNetworkRequested = task.Capabilities.HasFlag(BackgroundTaskCapability.Internet);
builder.Name = task.Id;
builder.SetTrigger(task.Trigger.GetTrigger());
Registrations.Add(builder.Register());
Debug.WriteLine($"Background task {task.Id} registered.");
return(true);
}
else
{
Debug.WriteLine($"Background activation of {task.Id} has been disabled by permission or power saving status.");
return(false);
}
}
public void HandleLine(string[] line)
{
var registration = new Registration(line);
if (string.IsNullOrEmpty(registration.Club))
{
registration.Club = "no club";
}
var club = Clubs.FirstOrDefault(c => string.Equals(c.Name, registration.Club, StringComparison.CurrentCultureIgnoreCase));
if (club == null)
{
club = new Club(registration.Club);
Clubs.Add(club);
}
club.AddRegistration(registration);
Registrations.Add(registration);
}
private void Apply(RobotRegistered e)
{
void AddRegistration()
{
var registration = new RobotRegistration.Registration(this, e);
Registrations = Registrations.Add(registration);
}
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
AddRegistration();
}
else
{
latestRegistration.Apply(
registration => throw new InvalidOperationException("Robot is already registered"),
unregistration => AddRegistration()
);
}
}
public async Task GetRegistrationsInternalAsync()
{
IsLoading = true;
try
{
Registrations.Clear();
var reg = await _notificationsFacade.GetRegistrationsAsync();
reg.ForEach(x => Registrations.Add(new RegistrationViewModel(x)));
if (reg.Count == 0)
{
MessageBox.Show("No items found.", "No Items");
}
}
catch (Exception ex)
{
MessageBox.Show($"An Error Occured. {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
IsLoading = false;
}
}
/// <summary>
/// Register a type and its mapped interface for injection.
/// </summary>
/// <typeparam name="TInterface">Mapped interface for registered type.</typeparam>
/// <typeparam name="TClass">Type to register.</typeparam>
public void Register <TInterface, TClass>() where TClass : class, TInterface
{
ValidateRegistration <TInterface, TClass>();
Registrations.Add(typeof(TInterface), typeof(TClass));
}
public void AddRegistration(Registration registration)
{
Registrations.Add(registration);
}
public TestServiceContainerWithStateManager()
{
Registrations.Add(typeof(TestStateManager), new TestStateManager());
}
