/// <summary>
/// Issues a ticket with flags using the singleton TicketProvider instance.
/// </summary>
/// <returns>The ticket issued by the provider.</returns>
public static string IssueTicket(int flags)
{
ITicketProvider ticketProvider = GetTicketProvider();
string ticket = ticketProvider.IssueTicket(flags);
return(ticket);
}
/// <summary>
/// Initializes a new instance of the <see cref="FchatService" /> class.
/// Chat connection is used to communicate with F-Chat using websockets.
/// </summary>
/// <param name="user">
/// The user.
/// </param>
/// <param name="eventagg">
/// The eventagg.
/// </param>
/// <param name="socket"></param>
/// <param name="provider"></param>
public FchatService(IAccount user, IEventAggregator eventagg, WebSocket socket, ITicketProvider provider)
{
this.socket = socket;
this.provider = provider;
Account = user.ThrowIfNull("user");
events = eventagg.ThrowIfNull("eventagg");
events.GetEvent<CharacterSelectedLoginEvent>()
.Subscribe(ConnectToChat, ThreadOption.BackgroundThread, true);
errsThatDisconnect = new[]
{
Constants.Errors.NoLoginSlots,
Constants.Errors.NoServerSlots,
Constants.Errors.KickedFromServer,
Constants.Errors.SimultaneousLoginKick,
Constants.Errors.BannedFromServer,
Constants.Errors.BadLoginInfo,
Constants.Errors.TooManyConnections,
Constants.Errors.UnknownLoginMethod
};
InitializeLog();
autoPingTimer.Elapsed += (s, e) => TrySend(Constants.ClientCommands.SystemPing);
autoPingTimer.Start();
staggerTimer = new Timer(GetNextConnectDelay()); // first reconnect is 5 seconds
staggerTimer.Elapsed += (s, e) => DoReconnect();
}
/// <summary>
/// Creates an ITicketProvider implementation. The instance is a singleton.
/// </summary>
/// <returns>A reference to the ITicketProvider implementation.</returns>
public static ITicketProvider GetTicketProvider()
{
string instanceName = "";
string className = "";
string assemblyName = "";
ITicketProvider ticketProvider = null;
try
{
lock (ticketProviderLock)
{
if (ticketProviderInstance == null)
{
SecuritySection section = SecuritySection.GetSection();
ClassSpecificationElement spec = section.TicketProvider;
instanceName = spec.Name;
className = spec.Class;
assemblyName = spec.Assembly;
ticketProviderInstance = (ITicketProvider)Factory.CreateComponent(instanceName, className, assemblyName);
}
ticketProvider = ticketProviderInstance;
}
}
catch (Exception exception)
{
throw new Exception("Failed to create ITicketProvider implementation.", exception);
}
return(ticketProvider);
}
public TestController(ITicketProvider ticketProvider, IContentLoader contentLoader, ReferenceConverter referenceConverter)
{
_ticketProvider = ticketProvider;
_client = SearchClient.Instance;
_contentLoader = contentLoader;
_referenceConverter = referenceConverter;
}
public AuthenticationService(IActiveDirectoryService adService,
ITicketProvider ticketProvider,
GlobalSettings settings,
IRoleService roleService,
IEncryptionService encryptionService)
{
_adService = adService;
_settings = settings;
_roleService = roleService;
_ticketProvider = ticketProvider;
_encryptionService = encryptionService;
}
public ChooseTicketTypeViewModel(IExpandedNavigation navigationService,
ITicketProvider ticketProvider, IAccountManager accountManager)
{
NavigationService = navigationService;
TicketProvider = ticketProvider;
AccountManager = accountManager;
OneTimeTickets = new ObservableCollection<Ticket>();
SeasonTickets = new ObservableCollection<Ticket>();
NavigateToBuyTicketCount
= new RelayCommand(ExecuteNavigateToBuyTicketCount);
DownloadTickets();
}
/// <summary>
/// Verifies that the current user belongs to the specified role.
/// </summary>
/// <param name="ticketProvider">Service provider, needed to retrieve the IHttpContextAccessor</param>
/// <param name="roles"></param>
public static void VerifyTicket(ITicketProvider ticketProvider, string roles)
{
if (!ticketProvider.IsAuthenticated())
{
throw new HyperlambdaException("Access denied", true, 401);
}
if (!string.IsNullOrEmpty(roles))
{
foreach (var idxRole in roles.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
if (ticketProvider.InRole(idxRole))
{
return;
}
}
throw new HyperlambdaException("Access denied", true, 401);
}
}
/// <summary>
/// Returns true if user belongs to any of the specified role(s) supplied as
/// a comma separated list of values.
/// </summary>
/// <param name="ticketProvider">Service provider, needed to retrieve the IHttpContextAccessor</param>
/// <param name="roles"></param>
public static bool InRole(ITicketProvider ticketProvider, string roles)
{
if (!ticketProvider.IsAuthenticated())
{
return(false);
}
if (!string.IsNullOrEmpty(roles))
{
foreach (var idxRole in roles.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
if (ticketProvider.InRole(idxRole))
{
return(true);
}
}
}
return(false);
}
public FlistService(IAccount model, IEventAggregator eventagg, IBrowser browser,
ITicketProvider ticketProvider)
{
this.browser = browser;
this.ticketProvider = ticketProvider;
try
{
this.model = model.ThrowIfNull("model");
events = eventagg.ThrowIfNull("eventagg");
events.GetEvent<LoginEvent>().Subscribe(GetTicket, ThreadOption.BackgroundThread);
events.GetEvent<UserCommandEvent>().Subscribe(HandleCommand, ThreadOption.BackgroundThread);
events.GetEvent<CharacterSelectedLoginEvent>().Subscribe(args => selectedCharacter = args);
// fix problem with SSL not being trusted on some machines
ServicePointManager.ServerCertificateValidationCallback =
(sender, certificate, chain, sslPolicyErrors) => true;
}
catch (Exception ex)
{
Exceptions.HandleException(ex);
}
}
/// <summary>
/// Creates a new instance of class.
/// </summary>
/// <param name="ticketProvider">Ticket provider, necessary to retrieve the authenticated user.</param>
public VerifyTicket(ITicketProvider ticketProvider)
{
_ticketProvider = ticketProvider;
}
/// <summary>
/// Returns the ticket belonging to the specified user.
/// </summary>
/// <param name="ticketProvider">Service provider, necessary to retrieve the IHttpContextAccessor</param>
/// <returns></returns>
public static Ticket GetTicket(ITicketProvider ticketProvider)
{
return(new Ticket(ticketProvider.Username, ticketProvider.Roles, ticketProvider.Claims));
}
/// <summary>
/// Creates a new instance of the class.
/// </summary>
/// <param name="ticketProvider">Your ticket provider.</param>
public GetTicket(ITicketProvider ticketProvider)
{
_ticketProvider = ticketProvider;
}
/// <summary>
/// Creates a new instance of the class.
/// </summary>
/// <param name="configuration">Configuration for your application.</param>
/// <param name="ticketProvider">Ticket provider, necessary to retrieve the authenticated user.</param>
public RefreshTicket(IConfiguration configuration, ITicketProvider ticketProvider)
{
_configuration = configuration;
_ticketProvider = ticketProvider;
}
public TicketController(ITicketProvider ticketProvider)
{
this.ticketProvider = ticketProvider;
}
public static async Task <IContentResult <TContentData> > GetResultAsync <TContentData>(this ITypeSearch <TContentData> search,
ITicketProvider ticketProvider,
int cacheForSeconds = 60,
bool cacheForEditorsAndAdmins = false) where TContentData : IContentData
{
await ticketProvider.WaitAsync(CancellationToken.None);
return(search.GetContentResultSafe(cacheForSeconds, cacheForEditorsAndAdmins));
}
/// <summary>
/// Creates a new instance of class.
/// </summary>
/// <param name="ticketProvider">Ticket provider, necessary to retrieve the authenticated user.</param>
public InRole(ITicketProvider ticketProvider)
{
_ticketProvider = ticketProvider;
}
