protected override async void OnStart() { if (IsOnStartCalled) { return; } var config = AppConfig.GetConfig(); AppCenter.Start( $"ios={config.AppCenteriOSKey};android={config.AppCenterAndroidKey};", typeof(Analytics), typeof(Crashes), typeof(Push)); Analytics.TrackEvent("AppStarted", new Dictionary <string, string>() { { nameof(config.AppCenterAndroidKey), config.AppCenterAndroidKey }, { nameof(config.AppCenteriOSKey), config.AppCenteriOSKey }, { nameof(config.RealmServerUrl), config.RealmServerUrl }, { nameof(config.RealmDatabase), config.RealmDatabase }, { "TimeZone", TimeZoneInfo.Local.ToSerializedString() } }); await RealmService.InitializeCloudSync(config.RealmServerUrl, config.RealmDatabase); IsOnStartCalled = true; }
public App() { var language = LanguageService.GetCurrentLanguage(); AppResources.Culture = new CultureInfo(language.GetLanguageCode()); var savedAppVersion = Portable.Helpers.Settings.AppVersion; var currentAppVersion = DependencyService.Get <IAppVersionProvider>().AppVersion; bool overwrite = savedAppVersion != currentAppVersion; RealmService.Initialize(overwrite); Portable.Helpers.Settings.AppVersion = currentAppVersion; this.InitializeComponent(); // Update Audit on startup Task.Run(UpdateService.UpdateAudit); AppCenter.Start( $"ios={IosAppCenterKey};android={AndroidAppCenterKey};", typeof(Analytics), typeof(Crashes)); Console.WriteLine("AuditUpdate. AppCenter InstallId: " + AppCenter.GetInstallIdAsync().Result); this.MainPage = new BottomTabbedPage(); }
public static async Task Main() { RealmService.InitializeOfflineDatabase(); var config = AppConfig.GetConfig(); await RealmService.InitializeCloudSync(config.RealmServerUrl, config.RealmDatabase); }
/// <summary>Initializes new instance of TestContext.</summary> public TestContext() { ConnectedUsers = new List<User>(); Entities = new List<object>(); Service = new RealmService(new TestProtocol()); Client = NewRealmClient(); Service.UserConnectionStateChanged += OnUserConnectionStateChanged; }
private List <Grouping <string, AboutPageItem> > GetAboutItems() { var aboutPageItems = new List <Grouping <string, AboutPageItem> >(); aboutPageItems.Add(new Grouping <string, AboutPageItem>("Friends", new AboutPageItem[] { new AboutPageItem { AboutItemType = AboutItemType.Friends } })); var communities = RealmService.Get <CommunityModel>(); var sessions = RealmService.Get <MeetupModel>(); var communitiesWithFirstSessionDate = communities.Join( sessions, c => c.Id, s => s.CommunityID, (c, s) => new { Community = c, FirstSessionDate = s.Sessions.OrderBy(session => session.StartTime).FirstOrDefault()?.StartTime }).OrderBy(x => x.FirstSessionDate).GroupBy(x => x.Community.Id).Select(x => x.First()); aboutPageItems.Add(new Grouping <string, AboutPageItem>("OurCommunities", communitiesWithFirstSessionDate.Select(x => new AboutPageItem { Community = x.Community, AboutItemType = AboutItemType.Community }))); var aboutAppItems = new Model.MenuItem[] { new Model.MenuItem { Name = "CreatedBy", Parameter = "CreatedBy" }, new Model.MenuItem { Name = "IssueTracker", Parameter = "IssueTracker" }, new Model.MenuItem { Name = "TechnologyUsed", Parameter = "TechnologyUsed" }, }; aboutPageItems.Add(new Grouping <string, AboutPageItem>("AboutApp", aboutAppItems.Select(x => new AboutPageItem { MenuItem = x, AboutItemType = AboutItemType.MenuItem }))); aboutPageItems.Add(new Grouping <string, AboutPageItem>("Settings", new AboutPageItem[] { new AboutPageItem { AboutItemType = AboutItemType.Settings } })); return(aboutPageItems); }
public static IList <SubscriptionModel> GetDefaultCommunitySubscriptionsByRealm(Realm realm) { return(DefaultCommunitySubscriptions.Union(RealmService.Get <CommunityModel>(realm).Select(x => new SubscriptionModel { Community = x, IsSelected = true, LoadedPosts = 100, Type = SocialMediaType.Vkontakte })).ToList()); }
public ToDoListPageViewModel(INavigationService navigationService, RealmService realmService ) : base(navigationService) { Title = AppResources.ViewATitle; RealmService = realmService; Tasks = new RangedObservableCollection <ToDoListItemViewModel>(); AddCommand = new DelegateCommand(AddTask); }
public App() { var language = LanguageService.GetCurrentLanguage(); AppResources.Culture = new CultureInfo(language.GetLanguageCode()); RealmService.Initialize(); this.InitializeComponent(); #if RELEASE AppCenter.Start( "ios=1e7f311f-1055-4ec9-8b00-0302015ab8ae;android=6f9a7703-8ca4-477e-9558-7e095f7d20aa;", typeof(Analytics), typeof(Crashes)); #endif this.MainPage = new BottomTabbedPage(); }
protected void RunServiceTests() { var realmService = RealmService.GetInstance <Models.Person>(); realmService.Write(() => { realmService.Add(new Person { Name = "Greg" }); realmService.Add(new Person { Name = "Jim" }); realmService.Add(new Person { Name = "Bob" }); }); // OR var personsRealm = new PersonsRealmService(); personsRealm.Write(() => { personsRealm.Add(new Person { Name = "Jan" }); personsRealm.Add(new Person { Name = "June" }); personsRealm.Add(new Person { Name = "Jinny" }); }); var persons = personsRealm.GetAll().ToList(); personsRealm.Write(() => { personsRealm.RemoveAll(); }); }
protected void RunEventTests() { var realmService = RealmService.GetInstance <Models.Person>(); var realmServiceTwo = RealmService.GetInstance <Models.Person>(); realmService.WriteFinished += (sender, args) => { var msg = "Woohoo!"; }; realmServiceTwo.WriteFinished += (sender, args) => { var msg = "Woohoo!"; }; realmService.Write(() => { realmService.Add(new Person { Name = "Greg" }); realmService.Add(new Person { Name = "Jim" }); realmService.Add(new Person { Name = "Bob" }); }); realmServiceTwo.Write(() => { realmService.Add(new Person { Name = "Greg" }); realmService.Add(new Person { Name = "Jim" }); realmService.Add(new Person { Name = "Bob" }); }); }
public App() { // workaround for https://github.com/realm/realm-dotnet/issues/1967 if (Xamarin.Forms.Device.RuntimePlatform != Xamarin.Forms.Device.iOS) { SyncConfigurationBase.Initialize(UserPersistenceMode.NotEncrypted); } VersionTracking.Track(); var language = LanguageService.GetCurrentLanguage(); AppResources.Culture = new CultureInfo(language.GetLanguageCode()); if (!IsAppCtorCalled) { RealmService.InitializeOfflineDatabase(); IsAppCtorCalled = true; } this.InitializeComponent(); this.MainPage = new AppShell(); }
public override async Task <ReadOnlyMemory <byte> > ExecuteCore(IKerberosMessage message, PreAuthenticationContext context) { // the logic for a TGS-REQ is relatively simple in the primary case where you have a TGT and want // to get a ticket to another service. It gets a bit more complicated when you need to do something // like a U2U exchange, renew, or get a referral to another realm. Realm referral isn't supported yet. // 1. Get the ApReq (TGT) from the PA-Data of the request // 2. Decrypt the TGT and extract the client calling identity // 3. Find the requested service principal // 4. Evaluate whether the client identity should get a ticket to the service // 5. Evaluate whether it should do U2U and if so extract that key instead // 6. Generate a service ticket for the calling client to the service // 7. return to client var tgsReq = (KrbTgsReq)message; logger.LogInformation("TGS-REQ incoming. SPN = {SPN}", tgsReq.Body.SName.FullyQualifiedName); var krbtgtIdentity = await RealmService.Principals.RetrieveKrbtgt(); var krbtgtKey = await krbtgtIdentity.RetrieveLongTermCredential(); var servicePrincipal = await RealmService.Principals.Find(tgsReq.Body.SName.FullyQualifiedName); // renewal is an odd case here because the SName will be krbtgt // does this need to be validated more than the Decrypt call? await EvaluateSecurityPolicy(context.Principal, servicePrincipal); KerberosKey serviceKey; if (tgsReq.Body.KdcOptions.HasFlag(KdcOptions.EncTktInSkey)) { serviceKey = GetUserToUserTicketKey(tgsReq.Body.AdditionalTickets, krbtgtKey); } else { serviceKey = await servicePrincipal.RetrieveLongTermCredential(); } var now = RealmService.Now(); TicketFlags flags = 0; if (tgsReq.Body.KdcOptions.HasFlag(KdcOptions.Forwardable)) { flags |= TicketFlags.Forwardable; } if (context.Ticket.Flags.HasFlag(TicketFlags.PreAuthenticated)) { flags |= TicketFlags.PreAuthenticated; } var tgsRep = await KrbKdcRep.GenerateServiceTicket <KrbTgsRep>( new ServiceTicketRequest { Principal = context.Principal, EncryptedPartKey = context.EncryptedPartKey, ServicePrincipal = servicePrincipal, ServicePrincipalKey = serviceKey, RealmName = RealmService.Name, Addresses = tgsReq.Body.Addresses, RenewTill = context.Ticket.RenewTill, StartTime = now - RealmService.Settings.MaximumSkew, EndTime = now + RealmService.Settings.SessionLifetime, Flags = flags, Now = now, Nonce = tgsReq.Body.Nonce, IncludePac = context.Ticket.AuthorizationData.Any(a => a.Type == AuthorizationDataType.AdIfRelevant) } ); return(tgsRep.EncodeApplication()); }
public override ReadOnlyMemory <byte> ExecuteCore(PreAuthenticationContext context) { // Now that we know who is requesting the ticket we can issue the ticket // // 3. Find the requested service principal // 4. Determine if the requested service principal is in another realm and if so refer them // 5. Evaluate whether the client identity should get a ticket to the service // 6. Evaluate whether it should do U2U and if so extract that key instead // 7. Generate a service ticket for the calling client to the service // 8. return to client var tgsReq = (KrbTgsReq)context.Message; if (context.ServicePrincipal == null) { // we can't find what they're asking for, but maybe it's in a realm we can transit? context.ServicePrincipal = ProposeTransitedRealm(tgsReq, context); } if (context.ServicePrincipal == null) { // we have no idea what service they're asking for and // there isn't a realm we can refer them to that can issue a ticket return(GenerateError( KerberosErrorCode.KDC_ERR_S_PRINCIPAL_UNKNOWN, "", RealmService.Name, tgsReq.Body.SName.FullyQualifiedName )); } // renewal is an odd case here because the SName will be krbtgt // does this need to be validated more than the Decrypt call? EvaluateSecurityPolicy(context.Principal, context.ServicePrincipal); KerberosKey serviceKey; if (tgsReq.Body.KdcOptions.HasFlag(KdcOptions.EncTktInSkey)) { serviceKey = GetUserToUserTicketKey(tgsReq.Body.AdditionalTickets, context); } else { serviceKey = context.ServicePrincipal.RetrieveLongTermCredential(); } var now = RealmService.Now(); TicketFlags flags = 0; if (tgsReq.Body.KdcOptions.HasFlag(KdcOptions.Forwardable)) { flags |= TicketFlags.Forwardable; } if (context.Ticket.Flags.HasFlag(TicketFlags.PreAuthenticated)) { flags |= TicketFlags.PreAuthenticated; } var includePac = DetectPacRequirement(tgsReq); if (includePac == null) { includePac = context.Ticket?.AuthorizationData?.Any(a => a.Type == AuthorizationDataType.AdIfRelevant) ?? false; } var tgsRep = KrbKdcRep.GenerateServiceTicket <KrbTgsRep>( new ServiceTicketRequest { KdcAuthorizationKey = context.EvidenceTicketKey, Principal = context.Principal, EncryptedPartKey = context.EncryptedPartKey, ServicePrincipal = context.ServicePrincipal, ServicePrincipalKey = serviceKey, RealmName = RealmService.Name, Addresses = tgsReq.Body.Addresses, RenewTill = context.Ticket.RenewTill, StartTime = now - RealmService.Settings.MaximumSkew, EndTime = now + RealmService.Settings.SessionLifetime, Flags = flags, Now = now, Nonce = tgsReq.Body.Nonce, IncludePac = includePac ?? false } ); return(tgsRep.EncodeApplication()); }
public void RemoveTests() { // No Primary Key var countriesService = RealmService.GetInstance <Models.Country>(); countriesService.Write(() => { countriesService.RemoveAll(); countriesService.Add(new Country { Name = "Canada" }); }); var country1 = countriesService.Get(x => x.Name == "Canada"); Assert.That(country1, Is.Not.Null); countriesService.Write(() => { countriesService.Remove(countriesService.Get(x => x.Name == "Canada")); }); country1 = countriesService.Get(x => x.Name == "Canada"); Assert.That(country1, Is.Null); // Primary Key, String var paintingsService = RealmService.GetInstance <Models.Painting>(); paintingsService.Write(() => { paintingsService.RemoveAll(); paintingsService.AddOrUpdate(new Painting { Id = "One", Name = "Gregory" }); paintingsService.AddOrUpdate(new Painting { Id = "Two", Name = "Bertha" }); }); var painting1 = paintingsService.Find("One"); var painting2 = paintingsService.Find("Two"); Assert.That(painting1, Is.Not.Null); Assert.That(painting2, Is.Not.Null); paintingsService.Write(() => { paintingsService.Remove("One"); paintingsService.Remove("Two"); }); painting1 = paintingsService.Find("One"); painting2 = paintingsService.Find("Two"); Assert.That(painting1, Is.Null); Assert.That(painting2, Is.Null); paintingsService.Write(() => { paintingsService.RemoveAll(); }); // Primary Key, AutoIncrement Disabled var animalsService = RealmService.GetInstance <Models.Animal>(); animalsService.Write(() => { animalsService.RemoveAll(); animalsService.Add(new Animal { Id = 3, Name = "Bertha" }); }); var animal1 = animalsService.Get(x => x.Name == "Bertha"); Assert.That(animal1, Is.Not.Null); animalsService.Write(() => { animalsService.Remove(animalsService.Get(x => x.Name == "Bertha")); }); animal1 = animalsService.Get(x => x.Name == "Bertha"); Assert.That(animal1, Is.Null); animalsService.Write(() => { animalsService.RemoveAll(); }); // Primary Key, AutoIncrement Enabled var personsService = RealmService.GetInstance <Models.Person>(); personsService.Write(() => { personsService.RemoveAll(); personsService.Add(new Person { Name = "Gregory" }); }); var person1 = personsService.Get(x => x.Name == "Gregory"); Assert.That(person1, Is.Not.Null); personsService.Write(() => { personsService.Remove(personsService.Get(x => x.Name == "Gregory")); }); person1 = personsService.Get(x => x.Name == "Gregory"); Assert.That(person1, Is.Null); personsService.Write(() => { personsService.RemoveAll(); }); }
protected override async Task <ReadOnlyMemory <byte> > ExecuteCore(IKerberosMessage message) { // the logic for a TGS-REQ is relatively simple in the primary case where you have a TGT and want // to get a ticket to another service. It gets a bit more complicated when you need to do something // like a U2U exchange, renew, or get a referral to another realm. Realm referral isn't supported yet. // 1. Get the ApReq (TGT) from the PA-Data of the request // 2. Decrypt the TGT and extract the client calling identity // 3. Find the requested service principal // 4. Evaluate whether the client identity should get a ticket to the service // 5. Evaluate whether it should do U2U and if so extract that key instead // 6. Generate a service ticket for the calling client to the service // 7. return to client var tgsReq = (KrbTgsReq)message; var apReq = ExtractApReq(tgsReq); var krbtgtIdentity = await RealmService.Principals.RetrieveKrbtgt(); var krbtgtKey = await krbtgtIdentity.RetrieveLongTermCredential(); var krbtgtApReqDecrypted = DecryptApReq(apReq, krbtgtKey); var principal = await RealmService.Principals.Find(krbtgtApReqDecrypted.Ticket.CName.FullyQualifiedName); var servicePrincipal = await RealmService.Principals.Find(tgsReq.Body.SName.FullyQualifiedName); // renewal is an odd case here because the SName will be krbtgt // does this need to be validated more than the Decrypt call? await EvaluateSecurityPolicy(principal, servicePrincipal, krbtgtApReqDecrypted); KerberosKey serviceKey; if (tgsReq.Body.KdcOptions.HasFlag(KdcOptions.EncTktInSkey)) { serviceKey = GetUserToUserTicketKey(tgsReq.Body.AdditionalTickets, krbtgtKey); } else { serviceKey = await servicePrincipal.RetrieveLongTermCredential(); } var now = RealmService.Now(); var tgsRep = await KrbKdcRep.GenerateServiceTicket <KrbTgsRep>( new ServiceTicketRequest { Principal = principal, EncryptedPartKey = krbtgtApReqDecrypted.SessionKey, ServicePrincipal = servicePrincipal, ServicePrincipalKey = serviceKey, RealmName = RealmService.Name, Addresses = tgsReq.Body.Addresses, RenewTill = krbtgtApReqDecrypted.Ticket.RenewTill, StartTime = now - RealmService.Settings.MaximumSkew, EndTime = now + RealmService.Settings.SessionLifetime, Flags = KrbKdcRep.DefaultFlags, Now = now } ); return(tgsRep.EncodeApplication()); }
private List <Grouping <string, AboutPageItem> > GetAboutItems() { var aboutPageItems = new List <Grouping <string, AboutPageItem> >(); aboutPageItems.Add(new Grouping <string, AboutPageItem>(nameof(AppResources.Friends), new [] { new AboutPageItem { AboutItemType = AboutItemType.Friends } })); aboutPageItems.Add(new Grouping <string, AboutPageItem>(nameof(AppResources.Subscriptions), new[] { new AboutPageItem { AboutItemType = AboutItemType.Subscriptions } })); var communities = RealmService.Get <CommunityModel>(); var sessions = RealmService.Get <MeetupModel>(); var communitiesWithFirstSessionDate = communities.Join( sessions, c => c.Id, s => s.CommunityID, (c, s) => new { Community = c, FirstSessionDate = s.Sessions.OrderBy(session => session.StartTime).FirstOrDefault()?.StartTime }).OrderBy(x => x.FirstSessionDate).GroupBy(x => x.Community.Id).Select(x => x.First()); aboutPageItems.Add(new Grouping <string, AboutPageItem>(nameof(AppResources.OurCommunities), communitiesWithFirstSessionDate.Select(x => new AboutPageItem { Community = x.Community, AboutItemType = AboutItemType.Community }))); var aboutAppItems = new [] { new Model.MenuItem { Name = nameof(AppResources.CreatedBy), Parameter = nameof(AppResources.CreatedBy) }, new Model.MenuItem { Name = nameof(AppResources.IssueTracker), Parameter = nameof(AppResources.IssueTracker) }, new Model.MenuItem { Name = nameof(AppResources.TechnologyUsed), Parameter = nameof(AppResources.TechnologyUsed) }, }; aboutPageItems.Add(new Grouping <string, AboutPageItem>(nameof(AppResources.AboutApp), aboutAppItems.Select(x => new AboutPageItem { MenuItem = x, AboutItemType = AboutItemType.MenuItem }))); aboutPageItems.Add(new Grouping <string, AboutPageItem>(nameof(AppResources.Settings), new [] { new AboutPageItem { AboutItemType = AboutItemType.Settings } })); return(aboutPageItems); }