public static List <SelectListItem> GetEditableAmenities()
        {
            List <SelectListItem> selectListItems = new List <SelectListItem>();

            selectListItems.AddRange(ConverterHelpers.EnumToKoSelectListItems <AmenityType>());
            return(selectListItems);
        }
예제 #2
0
        internal static CommunityForGridVm MapToCommunityForGridVm(this Community community)
        {
            string             name;
            CommunityForGridVm communityForGridVm = new CommunityForGridVm();
            List <KeyValuePair <int, string> > seniorHousingAndCareCategories = ItemTypeBc.Instance.GetSHCCategoriesForCommunity();

            communityForGridVm.Id         = community.Id;
            communityForGridVm.Name       = community.Name;
            communityForGridVm.BookNumber = community.Book.Number;
            communityForGridVm.CreateUser = community.CreateUserId;
            if (community.Package.HasValue)
            {
                name = Enum.GetName(typeof(PackageType), community.Package);
            }
            else
            {
                name = null;
            }
            communityForGridVm.Package  = name;
            communityForGridVm.Packages = new List <string>(Enum.GetNames(typeof(PackageType)));
            communityForGridVm.ActiveAdultCommunities         = community.ListingTypes.Any <ListingType>((ListingType m) => m == ListingType.ActiveAdultCommunities);
            communityForGridVm.ActiveAdultHomes               = community.ListingTypes.Any <ListingType>((ListingType m) => m == ListingType.ActiveAdultHomes);
            communityForGridVm.SeniorHousingAndCare           = (!community.ListingTypes.Any <ListingType>((ListingType m) => m == ListingType.SeniorHousingAndCare) || community.SeniorHousingAndCareCategoryIds == null ? false : community.SeniorHousingAndCareCategoryIds.Any <long>());
            communityForGridVm.SeniorHousingAndCareCategories = ConverterHelpers.DictionaryToCheckBoxList(seniorHousingAndCareCategories, community.SeniorHousingAndCareCategoryIds);
            communityForGridVm.ShowcaseStartDate              = community.Showcase.StartDate;
            communityForGridVm.ShowcaseEndDate  = community.Showcase.EndDate;
            communityForGridVm.PublishStartDate = community.Publishing.StartDate;
            communityForGridVm.PublishEndDate   = community.Publishing.EndDate;
            return(communityForGridVm);
        }
        public static NewCommunityVm GetNewCommunityVm()
        {
            NewCommunityVm newCommunityVm = new NewCommunityVm()
            {
                Books        = AccountBc.Instance.GetBooks().ToSelectListItemList(),
                ListingTypes = ConverterHelpers.EnumToCheckBoxList <ListingType>(),
                SeniorHousingAndCareCategories = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetSHCCategoriesForCommunity()),
                AgeRestrictions = ConverterHelpers.EnumToCheckBoxList <AgeRestriction>(),
                Address         = AdminViewModelsProvider.GetAddressVm(),
                PhoneList       = AdminViewModelsProvider.GetPhoneList(CommunityType.Community)
            };

            newCommunityVm.PhoneList.AdditionalPhones.ForEach((PhoneVm ph) => ph.PhoneTypes.RemoveAll((SelectListItem pt) => pt.get_Text().Contains("Provision")));
            newCommunityVm.EmailList = AdminViewModelsProvider.GetEmailListVm(CommunityType.Community);
            newCommunityVm.Contacts  = new List <ContactVm>()
            {
                AdminViewModelsProvider.GetContactVm(CommunityType.Community)
            };
            newCommunityVm.OfficeHours = new List <OfficeHoursVm>()
            {
                AdminViewModelsProvider.GetOfficeHoursVm()
            };
            newCommunityVm.CommunityDetails = AdminViewModelsProvider.GetCommunityDetailsVm();
            newCommunityVm.ListingDetails   = AdminViewModelsProvider.GetListingDetailsVm();
            return(newCommunityVm);
        }
        public static NewServiceProviderVm GetNewServiceProviderVm()
        {
            NewServiceProviderVm newServiceProviderVm = new NewServiceProviderVm()
            {
                Package           = new PackageType?(PackageType.Basic),
                Books             = AccountBc.Instance.GetBooks().ToSelectListItemList(),
                ServiceCategories = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetSHCCategoriesForServiceProvider()),
                AllCounties       = AdminViewModelsProvider.GetCounties(),
                CountiesServed    = new List <County>(),
                Address           = AdminViewModelsProvider.GetAddressVm(),
                PhoneList         = AdminViewModelsProvider.GetPhoneList(ServiceType.ProductsAndServices)
            };

            newServiceProviderVm.PhoneList.AdditionalPhones.ForEach((PhoneVm ph) => ph.PhoneTypes.RemoveAll((SelectListItem pt) => pt.get_Text().Contains("Provision")));
            newServiceProviderVm.EmailList = AdminViewModelsProvider.GetEmailListVm(ServiceType.ProductsAndServices);
            newServiceProviderVm.Contacts  = new List <ContactVm>()
            {
                AdminViewModelsProvider.GetContactVm(ServiceType.ProductsAndServices)
            };
            newServiceProviderVm.OfficeHours = new List <OfficeHoursVm>()
            {
                AdminViewModelsProvider.GetOfficeHoursVm()
            };
            newServiceProviderVm.PaymentTypes       = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes());
            newServiceProviderVm.Coupon             = new CouponVm();
            newServiceProviderVm.Images             = new ImageListVm(DisplayNames.ServiceProviderImages);
            newServiceProviderVm.CallTrackingPhones = new List <CallTrackingPhoneVm>()
            {
                new CallTrackingPhoneVm()
            };
            return(newServiceProviderVm);
        }
예제 #5
0
        public void SetParameter(InventorDocument document, string paramName, string value)
        {
            var parameter = document.Parameters.FirstOrDefault(x => x.Name == paramName);

            if (parameter == null)
            {
                LogManager.Add($"Could not find parameter {paramName} in {document.Name}");
                return;
            }

            switch (parameter.UnitType)
            {
            case UnitTypes.Length:
            case UnitTypes.Angular:
                parameter.Value = UnitManager.UnitsToInventor(ConverterHelpers.ConvertDouble(value), parameter.UnitType);
                break;

            case UnitTypes.Unitless:
                parameter.Value = ConverterHelpers.ConvertInt(value);
                break;

            case UnitTypes.Text:
                parameter.Value = value;
                break;
            }
        }
예제 #6
0
        internal static ServiceProviderForGridVm MapToServiceProviderForGridVm(this ServiceProvider serviceProvider)
        {
            string name;
            ServiceProviderForGridVm           serviceProviderForGridVm       = new ServiceProviderForGridVm();
            List <KeyValuePair <int, string> > seniorHousingAndCareCategories = ItemTypeBc.Instance.GetSHCCategoriesForServiceProvider();

            serviceProviderForGridVm.Id   = serviceProvider.Id;
            serviceProviderForGridVm.Name = serviceProvider.Name;
            if (serviceProvider.Package.HasValue)
            {
                name = Enum.GetName(typeof(PackageType), serviceProvider.Package);
            }
            else
            {
                name = null;
            }
            serviceProviderForGridVm.Package  = name;
            serviceProviderForGridVm.Packages = new List <string>(Enum.GetNames(typeof(PackageType)));
            serviceProviderForGridVm.SeniorHousingAndCareCategories = ConverterHelpers.DictionaryToCheckBoxList(seniorHousingAndCareCategories, (
                                                                                                                    from sc in serviceProvider.ServiceCategories
                                                                                                                    select sc.Key).ToList <long>());
            serviceProviderForGridVm.FeatureStartDate = serviceProvider.FeatureStartDate;
            serviceProviderForGridVm.FeatureEndDate   = serviceProvider.FeatureEndDate;
            serviceProviderForGridVm.PublishStartDate = serviceProvider.PublishStartDate;
            serviceProviderForGridVm.PublishEndDate   = serviceProvider.PublishEndDate;
            return(serviceProviderForGridVm);
        }
예제 #7
0
        public NSString GetListViewPageDataAsBase64String(NSString noValue)
        {
            var listPageData = App.GetListPageData();

            var listPageDataAsBase64String = ConverterHelpers.ConvertSerializableObjectToBase64String(listPageData);

            return(new NSString(listPageDataAsBase64String));
        }
예제 #8
0
 public static EditServiceProviderVm Repopulate(this EditServiceProviderVm model)
 {
     model.PhoneList    = model.PhoneList.Repopulate(ServiceType.ProductsAndServices);
     model.EmailList    = model.EmailList.Repopulate(ServiceType.ProductsAndServices);
     model.Contacts     = model.Contacts.Repopulate(ServiceType.ProductsAndServices);
     model.PaymentTypes = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes());
     return(model);
 }
예제 #9
0
        public string GetListViewPageDataAsBase64String()
        {
            var listPageData = App.GetListPageData();

            var listPageDataAsBase64String = ConverterHelpers.ConvertSerializableObjectToBase64String(listPageData);

            return(listPageDataAsBase64String);
        }
예제 #10
0
 public static NewServiceProviderVm Repopulate(this NewServiceProviderVm model)
 {
     model.PhoneList = model.PhoneList.Repopulate(ServiceType.ProductsAndServices);
     model.PhoneList.AdditionalPhones.ForEach((PhoneVm ph) => ph.PhoneTypes.RemoveAll((SelectListItem pt) => pt.get_Text().Contains("Provision")));
     model.EmailList    = model.EmailList.Repopulate(ServiceType.ProductsAndServices);
     model.Contacts     = model.Contacts.Repopulate(ServiceType.ProductsAndServices);
     model.PaymentTypes = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes());
     return(model);
 }
        public static CommunityDetailsVm GetCommunityDetailsVm()
        {
            CommunityDetailsVm communityDetailsVm = new CommunityDetailsVm()
            {
                PaymentTypes   = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes()),
                PriceRange     = new MeasureBoundaryVm <decimal, MoneyType>(),
                Deposit        = new MeasureBoundaryVm <decimal, MoneyType>(),
                ApplicationFee = new MeasureBoundaryVm <decimal, MoneyType>(),
                PetDeposit     = new MeasureBoundaryVm <decimal, MoneyType>(),
                LivingSpace    = new MeasureBoundaryVm <int, LivingSpaceMeasure>(),
                AvailableBedroomsFromQuantity  = MSLivingChoices.Bcs.Components.ItemTypeBc.Instance.GetBedrooms().ToSelectListItemList(),
                AvailableBedroomsToQuantity    = communityDetailsVm.AvailableBedroomsFromQuantity,
                AvailableBathroomsFromQuantity = MSLivingChoices.Bcs.Components.ItemTypeBc.Instance.GetBathrooms().ToSelectListItemList(),
                AvailableBathroomsToQuantity   = communityDetailsVm.AvailableBathroomsFromQuantity,
                DefaultAmenities = AmenityBc.Instance.GetDefaultAmenities(CommunityType.Community).ConvertAll <CheckBoxVm>((Amenity m) => new CheckBoxVm()
                {
                    Value = m.ClassId.ToString(),
                    Text  = m.Name
                }),
                CustomAmenities = new List <AmenityVm>()
                {
                    new AmenityVm()
                },
                DefaultCommunityServices = CommunityServiceBc.Instance.GetDefaultCommunityServices().ConvertAll <CheckBoxVm>((CommunityService m) => new CheckBoxVm()
                {
                    Value = m.AdditionInfoTypeId.ToString(),
                    Text  = m.Name
                }),
                CustomCommunityServices = new List <CommunityServiceVm>()
                {
                    new CommunityServiceVm(),
                    new CommunityServiceVm()
                }
            };

            communityDetailsVm.CustomCommunityServices = new List <CommunityServiceVm>()
            {
                new CommunityServiceVm()
            };
            communityDetailsVm.Coupon     = new CouponVm();
            communityDetailsVm.FloorPlans = new List <FloorPlanVm>()
            {
                AdminViewModelsProvider.GetCommunityUnit(CommunityUnitType.FloorPlan)
            };
            communityDetailsVm.SpecHomes = new List <SpecHomeVm>()
            {
                AdminViewModelsProvider.GetCommunityUnit(CommunityUnitType.SpecHome)
            };
            communityDetailsVm.Houses = new List <HouseVm>()
            {
                AdminViewModelsProvider.GetHouseUnit()
            };
            communityDetailsVm.Images     = new ImageListVm(DisplayNames.CommunityImages);
            communityDetailsVm.LogoImages = new ImageListVm(DisplayNames.CommunityLogo);
            return(communityDetailsVm);
        }
        public void SelectVenues(string judgeNames)
        {
            _browsers[_c.CurrentUser].Driver.WaitUntilVisible(VhoVenueAllocationPage.VenuesDropdown).Displayed.Should().BeTrue();
            _browsers[_c.CurrentUser].Click(VhoVenueAllocationPage.VenuesTextBox);

            foreach (var venue in ConverterHelpers.ConvertStringIntoArray(judgeNames))
            {
                _browsers[_c.CurrentUser].Driver.WaitUntilVisible(VhoVenueAllocationPage.VenuesTextBox).SendKeys(venue);
                _browsers[_c.CurrentUser].ClickCheckbox(VhoVenueAllocationPage.VenueCheckbox(venue), 5);
            }
        }
예제 #13
0
    public override DimensionCodec?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType != JsonTokenType.StartObject)
        {
            throw new JsonException($"Expected StartObject got: {reader.TokenType}");
        }

        var dimensionCodec = new DimensionCodec();

        var props = typeToConvert.GetProperties();

        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.EndObject)
            {
                return(dimensionCodec);
            }

            if (reader.TokenType != JsonTokenType.PropertyName)
            {
                throw new JsonException($"Expected property name got: {reader.TokenType}");
            }

            var propName = reader.GetString();

            reader.Read();

            if (string.IsNullOrWhiteSpace(propName))
            {
                throw new JsonException("Property name was null.");
            }

            foreach (var(name, property) in this.propertyMap)
            {
                var convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;

                if (!propName.Equals(convertedName, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                if (!ConverterHelpers.TryGetAction(property.PropertyType, out var action))
                {
                    dimensionCodec.Element = JsonSerializer.Deserialize <DimensionElement>(ref reader, options);
                    continue;
                }

                action.Invoke(dimensionCodec, ref reader, property);
            }
        }

        throw new JsonException($"Expected EndObject got: {reader.TokenType}");
    }
        public static EditServiceProviderVm GetEditServiceProviderVm(long id)
        {
            if (!ServiceProviderBc.Instance.IsUsersService(id))
            {
                return(null);
            }
            ServiceProvider       serviceProvider       = ServiceProviderBc.Instance.GetById(id);
            EditServiceProviderVm editServiceProviderVm = new EditServiceProviderVm()
            {
                Id = serviceProvider.Id,
                MarchexAccountId  = serviceProvider.MarchexAccountId,
                BookId            = serviceProvider.Book.Id,
                Books             = AccountBc.Instance.GetBooks().ToSelectListItemList(),
                ServiceCategories = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetSHCCategoriesForServiceProvider(), (
                                                                                  from sc in serviceProvider.ServiceCategories
                                                                                  select sc.Key).ToList <long>()),
                AllCounties    = AdminViewModelsProvider.GetCounties(),
                CountiesServed = ServiceProviderBc.Instance.GetCountiesServedById(id),
                PhoneList      = serviceProvider.Phones.MapToPhoneListVm(ServiceType.ProductsAndServices)
            };

            editServiceProviderVm.PhoneList.AdditionalPhones.ForEach((PhoneVm ph) => ph.PhoneTypes.RemoveAll((SelectListItem pt) => pt.get_Text().Contains("Provision")));
            editServiceProviderVm.EmailList = serviceProvider.Emails.MapToEmailListVm(ServiceType.ProductsAndServices);
            List <KeyValuePair <int, string> > contactTypes = MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetContactTypes(ServiceType.ProductsAndServices);

            editServiceProviderVm.Contacts = (serviceProvider.Contacts == null || !serviceProvider.Contacts.Any <Contact>() ? new List <ContactVm>()
            {
                AdminViewModelsProvider.GetContactVm(ServiceType.ProductsAndServices)
            } : serviceProvider.Contacts.ConvertAll <ContactVm>((Contact m) => AdminViewModelsProvider.GetContactVm(m, contactTypes)));
            editServiceProviderVm.OfficeHours = (serviceProvider.OfficeHours == null || !serviceProvider.OfficeHours.Any <OfficeHours>() ? new List <OfficeHoursVm>()
            {
                AdminViewModelsProvider.GetOfficeHoursVm()
            } : serviceProvider.OfficeHours.ConvertAll <OfficeHoursVm>((OfficeHours m) => new OfficeHoursVm(m)));
            editServiceProviderVm.FeatureStartDate  = serviceProvider.FeatureStartDate;
            editServiceProviderVm.FeatureEndDate    = serviceProvider.FeatureEndDate;
            editServiceProviderVm.Description       = serviceProvider.Description;
            editServiceProviderVm.WebsiteUrl        = serviceProvider.WebsiteUrl;
            editServiceProviderVm.DisplayWebsiteUrl = serviceProvider.DisplayWebsiteUrl;
            editServiceProviderVm.Name                         = serviceProvider.Name;
            editServiceProviderVm.PublishEndDate               = serviceProvider.PublishEndDate;
            editServiceProviderVm.PublishStartDate             = serviceProvider.PublishStartDate;
            editServiceProviderVm.Package                      = serviceProvider.Package;
            editServiceProviderVm.Address                      = (serviceProvider.Address == null ? AdminViewModelsProvider.GetAddressVm() : serviceProvider.Address.MapToAddressVm());
            editServiceProviderVm.DoNotDisplayAddress          = !serviceProvider.DisplayAddress;
            editServiceProviderVm.PaymentTypes                 = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes(), serviceProvider.PaymentTypeIds);
            editServiceProviderVm.Images                       = serviceProvider.Images.MapToImageListVm(DisplayNames.ServiceProviderImages);
            editServiceProviderVm.Coupon                       = (serviceProvider.Coupon != null ? serviceProvider.Coupon.MapToCouponVm() : new CouponVm());
            editServiceProviderVm.ProvisionCallTrackingNumbers = serviceProvider.CallTrackingPhones.Any <CallTrackingPhone>();
            editServiceProviderVm.CallTrackingPhones           = AdminViewModelsProvider.GetCallTrackingPhoneVmList(serviceProvider.CallTrackingPhones);
            return(editServiceProviderVm);
        }
예제 #15
0
 internal static FilterForServiceProviderGridVm MapToFilterForServiceProviderGridVm(this ServiceProviderGridFilter filter)
 {
     return(new FilterForServiceProviderGridVm()
     {
         ServiceProvider = filter.ServiceProvider,
         Feature = filter.Feature,
         FeatureStart = filter.FeatureStart,
         FeatureEnd = filter.FeatureEnd,
         Publish = filter.Publish,
         PublishStart = filter.PublishStart,
         PublishEnd = filter.PublishEnd,
         Packages = ConverterHelpers.DictionaryToCheckBoxList(ItemTypeBc.Instance.GetAdditionalInfo(AdditionalInfoClass.Package), filter.Packages.ConvertAll <long>((KeyValuePair <int, string> x) => (long)x.Key)),
         Categories = ConverterHelpers.DictionaryToCheckBoxList(ItemTypeBc.Instance.GetSHCCategoriesForServiceProvider(), filter.Categories.ConvertAll <long>((KeyValuePair <int, string> x) => (long)x.Key))
     });
 }
예제 #16
0
        internal static List <ListPageDataModel> GetListPageData(IApp app)
        {
            string listPageDataAsBase64String;

            if (app is iOSApp)
            {
                listPageDataAsBase64String = app.Invoke("getListViewPageDataAsBase64String:", "").ToString();
            }
            else
            {
                listPageDataAsBase64String = app.Invoke("GetListViewPageDataAsBase64String").ToString();
            }

            return(ConverterHelpers.DeserializeObject <List <ListPageDataModel> >(listPageDataAsBase64String));
        }
        public static EditCommunityVm GetEditCommunityVm(long id)
        {
            if (!CommunityBc.Instance.IsUsersCommunity(id))
            {
                return(null);
            }
            Community       community       = CommunityBc.Instance.GetById(id);
            EditCommunityVm editCommunityVm = new EditCommunityVm();

            editCommunityVm.Id = community.Id;
            editCommunityVm.MarchexAccountId = community.MarchexAccountId;
            editCommunityVm.BookId           = community.Book.Id;
            editCommunityVm.Books            = AccountBc.Instance.GetBooks().ToSelectListItemList();
            editCommunityVm.Package          = community.Package;
            editCommunityVm.ListingTypes     = ConverterHelpers.EnumToCheckBoxList(community.ListingTypes);
            editCommunityVm.SeniorHousingAndCareCategories = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetSHCCategoriesForCommunity(), community.SeniorHousingAndCareCategoryIds);
            editCommunityVm.AgeRestrictions     = ConverterHelpers.EnumToCheckBoxList(community.AgeRestrictions);
            editCommunityVm.Name                = community.Name;
            editCommunityVm.Address             = community.Address.MapToAddressVm();
            editCommunityVm.DoNotDisplayAddress = !community.DisplayAddress;
            editCommunityVm.PhoneList           = community.Phones.MapToPhoneListVm(CommunityType.Community);
            editCommunityVm.PhoneList.AdditionalPhones.ForEach(delegate(PhoneVm ph)
            {
                ph.PhoneTypes.RemoveAll((SelectListItem pt) => pt.Text.Contains("Provision"));
            });
            editCommunityVm.EmailList = community.Emails.MapToEmailListVm(CommunityType.Community);
            List <KeyValuePair <int, string> > contactTypes = MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetContactTypes(CommunityType.Community);

            editCommunityVm.Contacts = ((community.Contacts != null && community.Contacts.Any()) ? community.Contacts.ConvertAll((Contact m) => GetContactVm(m, contactTypes)) : new List <ContactVm>
            {
                GetContactVm(CommunityType.Community)
            });
            editCommunityVm.OfficeHours = ((community.OfficeHours != null && community.OfficeHours.Any()) ? community.OfficeHours.ConvertAll((OfficeHours m) => new OfficeHoursVm(m)) : new List <OfficeHoursVm>
            {
                GetOfficeHoursVm()
            });
            editCommunityVm.Description       = community.Description;
            editCommunityVm.WebsiteUrl        = community.WebsiteUrl;
            editCommunityVm.DisplayWebsiteUrl = community.DisplayWebsiteUrl;
            editCommunityVm.ListingDetails    = community.MapToListingDetailsVm();
            editCommunityVm.CommunityDetails  = community.MapToCommunityDetailsVm();
            editCommunityVm.PublishStart      = community.Publishing.StartDate;
            editCommunityVm.PublishEnd        = community.Publishing.EndDate;
            editCommunityVm.ShowcaseStart     = community.Showcase.StartDate;
            editCommunityVm.ShowcaseEnd       = community.Showcase.EndDate;
            return(editCommunityVm);
        }
예제 #18
0
 internal static FilterForCommunityGridVm MapToFilterForCommunityGridVm(this CommunityGridFilter filter)
 {
     return(new FilterForCommunityGridVm()
     {
         AAC = filter.AAC,
         AAH = filter.AAH,
         Community = filter.Community,
         Packages = ConverterHelpers.DictionaryToCheckBoxList(ItemTypeBc.Instance.GetAdditionalInfo(AdditionalInfoClass.Package), filter.Packages.ConvertAll <long>((KeyValuePair <int, string> x) => (long)x.Key)),
         Publish = filter.Publish,
         PublishEnd = filter.PublishEnd,
         PublishStart = filter.PublishStart,
         SHC = filter.SHC,
         Showcase = filter.Showcase,
         ShowcaseStart = filter.ShowcaseStart,
         ShowcaseEnd = filter.ShowcaseEnd,
         SHCCategories = ConverterHelpers.DictionaryToCheckBoxList(ItemTypeBc.Instance.GetSHCCategoriesForCommunity(), filter.Categories.ConvertAll <long>((KeyValuePair <int, string> x) => (long)x.Key))
     });
 }
예제 #19
0
            public async Task Render(HttpRequest request, HttpResponse response, APEntity toRender)
            {
                response.ContentType = ConverterHelpers.GetBestMatch(_factory.MimeTypes, request.Headers["Accept"]);
                if (toRender.Type.Contains("Tombstone"))
                {
                    response.StatusCode = 410;
                }

                if (request.Method == "POST")
                {
                    response.StatusCode = 201;
                    response.Headers.Add("Location", toRender.Id);
                }

                var depth       = Math.Min(int.Parse(request.Query["depth"].FirstOrDefault() ?? "3"), 5);
                var unflattened = await _flattener.Unflatten(_entityStore, toRender, depth, isOwner : toRender.IsOwner);

                await response.WriteAsync(unflattened.Serialize(true).ToString());
            }
        internal static List <ListPageDataModel> GetListPageData(IApp app)
        {
            string listPageDataAsBase64String;

            switch (app)
            {
            case iOSApp iosApp:
                listPageDataAsBase64String = iosApp.Invoke("getSerializedListViewPageData:", "").ToString();
                break;

            case AndroidApp androidApp:
                listPageDataAsBase64String = androidApp.Invoke("GetSerializedListViewPageData").ToString();
                break;

            default:
                throw new NotSupportedException("Platform Not Supported");
            }

            return(ConverterHelpers.DeserializeObject <List <ListPageDataModel> >(listPageDataAsBase64String));
        }
예제 #21
0
        public async Task Invoke(HttpContext context, IServiceProvider serviceProvider, EntityData entityData, IEntityStore store)
        {
            var handler = ActivatorUtilities.CreateInstance <GetEntityHandler>(serviceProvider, context.User);

            if (entityData.RewriteRequestScheme)
            {
                context.Request.Scheme = "https";
            }

            var fullpath = $"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}";

            foreach (var converterFactory in _converters)
            {
                if (converterFactory.FileExtension != null && fullpath.EndsWith("." + converterFactory.FileExtension))
                {
                    fullpath = fullpath.Substring(0, fullpath.Length - 1 - converterFactory.FileExtension.Length);
                    context.Request.Headers.Remove("Accept");
                    context.Request.Headers.Add("Accept", converterFactory.RenderMimeType);
                    break;
                }
            }

            /* && ConverterHelpers.GetBestMatch(_converters[0].MimeTypes, context.Request.Headers["Accept"]) != null */
            if (context.Request.Method == "OPTIONS")
            {
                context.Response.StatusCode = 200;
                context.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
                context.Response.Headers.Add("Access-Control-Allow-Headers", "Authorization");
                context.Response.Headers.Add("Access-Control-Allow-Methods", "GET, POST");
                context.Response.Headers.Add("Access-Control-Allow-Origin", context.Request.Headers["Origin"]);
                context.Response.Headers.Add("Vary", "Origin");
                return;
            }

            Console.WriteLine(fullpath);
            foreach (var line in context.Request.Headers["Accept"])
            {
                Console.WriteLine($"---- {line}");
            }

            if (context.Request.Headers["Accept"].Contains("text/event-stream"))
            {
                await handler.EventStream(context, fullpath);

                return;
            }


            if (context.WebSockets.IsWebSocketRequest)
            {
                await handler.WebSocket(context, fullpath);

                return;
            }

            if (context.Request.Method == "POST" && context.Request.ContentType.StartsWith("multipart/form-data"))
            {
                context.Items.Add("fullPath", fullpath);
                context.Request.Path = "/settings/uploadMedia";
                await _next(context);

                return;
            }

            if (context.Request.QueryString.Value == "?hub")
            {
                context.Items.Add("fullPath", fullpath);
                context.Request.Path        = "/.well-known/hub";
                context.Request.QueryString = QueryString.Empty;
                await _next(context);

                return;
            }

            IConverter readConverter  = null;
            IConverter writeConverter = null;
            bool       needRead       = context.Request.Method == "POST";
            var        target         = fullpath;
            APEntity   targetEntity   = null;

            targetEntity = await store.GetEntity(target, false);

            if (needRead)
            {
                if (targetEntity?.Type == "_inbox")
                {
                    target = (string)targetEntity.Data["attributedTo"].Single().Primitive;
                }
            }

            if (targetEntity == null)
            {
                await _next(context);

                return;
            }


            foreach (var converterFactory in _converters)
            {
                bool worksForWrite = converterFactory.CanRender && ConverterHelpers.GetBestMatch(converterFactory.MimeTypes, context.Request.Headers["Accept"]) != null;
                bool worksForRead  = needRead && converterFactory.CanParse && ConverterHelpers.GetBestMatch(converterFactory.MimeTypes, context.Request.ContentType) != null;

                if (worksForRead && worksForWrite && readConverter == null && writeConverter == null)
                {
                    readConverter = writeConverter = converterFactory.Build(serviceProvider, target);
                    break;
                }

                if (worksForRead && readConverter == null)
                {
                    readConverter = converterFactory.Build(serviceProvider, target);
                }

                if (worksForWrite && writeConverter == null)
                {
                    writeConverter = converterFactory.Build(serviceProvider, target);
                }
            }

            ASObject data = null;

            if (readConverter != null)
            {
                data = await readConverter.Parse(context.Request.Body);
            }

            if (needRead && readConverter != null && writeConverter == null)
            {
                writeConverter = readConverter;
            }

            if (data == null && needRead && targetEntity != null)
            {
                context.Response.StatusCode = 415;
                await context.Response.WriteAsync("Unknown mime type " + context.Request.ContentType);

                return;
            }

            var arguments = context.Request.Query;

            try
            {
                if (context.Request.Method == "GET" || context.Request.Method == "HEAD" || context.Request.Method == "OPTIONS")
                {
                    data = await handler.Get(fullpath, arguments, context);
                }
                else if (context.Request.Method == "POST" && data != null)
                {
                    data = await handler.Post(context, fullpath, data);
                }
            }
            catch (UnauthorizedAccessException e)
            {
                context.Response.StatusCode = 403;
                await context.Response.WriteAsync(e.Message);
            }
            catch (InvalidOperationException e)
            {
                context.Response.StatusCode = 401;
                await context.Response.WriteAsync(e.Message);
            }

            if (context.Response.HasStarted)
            {
                return;
            }

            if (data != null)
            {
                if (context.Request.Method == "HEAD")
                {
                    context.Response.StatusCode = 200;
                    return;
                }

                if (writeConverter != null)
                {
                    await writeConverter.Render(context.Request, context.Response, data);
                }
                else if (context.Request.ContentType == "application/magic-envelope+xml")
                {
                    context.Response.StatusCode = 202;
                    await context.Response.WriteAsync("accepted");
                }
                else
                {
                    context.Request.Method  = "GET";
                    context.Request.Path    = "/render";
                    context.Items["object"] = APEntity.From(data);
                    await _next(context);
                }
                return;
            }

            if (!context.Response.HasStarted)
            {
                await _next(context);
            }
        }
        public virtual ServiceProvider ToEntity()
        {
            long            id;
            ServiceProvider serviceProvider = new ServiceProvider();
            List <long>     paymentTypeIds  = new List <long>();

            foreach (CheckBoxVm checkBoxVm in
                     from m in this.PaymentTypes
                     where m.IsChecked
                     select m)
            {
                if (!long.TryParse(checkBoxVm.Value, out id))
                {
                    continue;
                }
                paymentTypeIds.Add(id);
            }
            serviceProvider.PaymentTypeIds = paymentTypeIds;
            serviceProvider.Coupon         = this.Coupon.ToEntity();
            serviceProvider.Package        = this.Package;
            serviceProvider.Book           = new Book()
            {
                Id = this.BookId
            };
            serviceProvider.ServiceCategories = (
                from key in ConverterHelpers.CheckBoxListToLongArray(this.ServiceCategories)
                select new KeyValuePair <long, string>(key, string.Empty)).ToList <KeyValuePair <long, string> >();
            serviceProvider.AllCounties    = this.AllCounties;
            serviceProvider.CountiesServed = this.CountiesServed;
            serviceProvider.Name           = this.Name;
            serviceProvider.Address        = (this.AddressValidation.ValidationItems == null ? this.Address.ToEntity() : this.AddressValidation.ToEntity());
            serviceProvider.DisplayAddress = !this.DoNotDisplayAddress;
            serviceProvider.Phones         = this.PhoneList.ToEntityList();
            serviceProvider.Emails         = this.EmailList.ToEntity();
            serviceProvider.Contacts       = this.Contacts.ConvertAll <Contact>((ContactVm m) => m.ToEntity()).Where <Contact>((Contact x) => {
                if (!string.IsNullOrWhiteSpace(x.FirstName))
                {
                    return(true);
                }
                return(!string.IsNullOrWhiteSpace(x.LastName));
            }).ToList <Contact>();
            serviceProvider.OfficeHours        = this.OfficeHours.ConvertAll <MSLivingChoices.Entities.Admin.OfficeHours>((OfficeHoursVm m) => m.ToEntity());
            serviceProvider.Description        = this.Description;
            serviceProvider.WebsiteUrl         = MslcUrlBuilder.NormalizeUri(this.WebsiteUrl);
            serviceProvider.DisplayWebsiteUrl  = this.DisplayWebsiteUrl;
            serviceProvider.FeatureStartDate   = this.FeatureStartDate;
            serviceProvider.FeatureEndDate     = this.FeatureEndDate;
            serviceProvider.PublishStartDate   = this.PublishStartDate;
            serviceProvider.PublishEndDate     = this.PublishEndDate;
            serviceProvider.Images             = (this.Images != null ? this.Images.ToEntity(ImageType.Photo) : new List <Image>());
            serviceProvider.CallTrackingPhones = new List <CallTrackingPhone>();
            if (this.CallTrackingPhones != null)
            {
                if (!this.ProvisionCallTrackingNumbers)
                {
                    this.CallTrackingPhones.ForEach((CallTrackingPhoneVm c) => c.IsDisconnected = true);
                }
                serviceProvider.CallTrackingPhones = (
                    from p in this.CallTrackingPhones.ConvertAll <CallTrackingPhone>((CallTrackingPhoneVm m) => m.ToEntity())
                    where !string.IsNullOrEmpty(p.Phone)
                    select p).ToList <CallTrackingPhone>();
            }
            return(serviceProvider);
        }
예제 #23
0
        protected override void buttonCaptureDims_Click(object sender, EventArgs e)
        {
            var dims = SolidworksApplication.ActiveDocument.GetDimensions();

            foreach (var d in dims.Dimensions)
            {
                this.Dimensions.Add(new DimensionCapture(SolidworksFormatters.RemoveDocumentNameFromDimension(d.Name), ConverterHelpers.Round(d.Value, 16)));
            }

            foreach (var f in dims.Features)
            {
                this.Features.Add(new FeatureCapture(f.Name, f.FeatureType, f.Suppressed));
            }
        }
예제 #24
0
        internal static CommunityDetailsVm MapToCommunityDetailsVm(this Community community)
        {
            CommunityDetailsVm communityDetails = new CommunityDetailsVm()
            {
                PaymentTypes   = ConverterHelpers.DictionaryToCheckBoxList(MSLivingChoices.Bcs.Admin.Components.ItemTypeBc.Instance.GetPaymentTypes(), community.PaymentTypeIds),
                PriceRange     = community.PriceRange.MapToMeasureBoundaryVm <decimal, MoneyType>(),
                Deposit        = community.Deposit.MapToMeasureBoundaryVm <decimal, MoneyType>(),
                ApplicationFee = community.ApplicationFee.MapToMeasureBoundaryVm <decimal, MoneyType>(),
                PetDeposit     = community.PetDeposit.MapToMeasureBoundaryVm <decimal, MoneyType>(),
                LivingSpace    = community.LivingSpace.MapToMeasureBoundaryVm <int, LivingSpaceMeasure>(),
                BathroomFromId = community.BathroomFromId,
                BathroomToId   = community.BathroomToId
            };
            List <KeyValuePair <int, string> > bedrooms = MSLivingChoices.Bcs.Components.ItemTypeBc.Instance.GetBedrooms();

            communityDetails.AvailableBedroomsFromQuantity = bedrooms.ToSelectListItemList(community.BedroomFromId);
            communityDetails.AvailableBedroomsToQuantity   = bedrooms.ToSelectListItemList(community.BedroomToId);
            communityDetails.BedroomFromId = community.BedroomFromId;
            communityDetails.BedroomToId   = community.BedroomToId;
            List <KeyValuePair <int, string> > bathrooms = MSLivingChoices.Bcs.Components.ItemTypeBc.Instance.GetBathrooms();

            communityDetails.AvailableBathroomsFromQuantity = bathrooms.ToSelectListItemList(community.BathroomFromId);
            communityDetails.AvailableBathroomsToQuantity   = bathrooms.ToSelectListItemList(community.BathroomToId);
            communityDetails.UnitCount = community.UnitCount;
            List <Amenity> defaultCommunityAmenities = AmenityBc.Instance.GetDefaultAmenities(CommunityType.Community);

            communityDetails.DefaultAmenities = community.Amenities.MapToCheckBoxVmList(defaultCommunityAmenities);
            communityDetails.CustomAmenities  = community.Amenities.MapToAmenityVmList(defaultCommunityAmenities);
            List <CommunityService> defaultCommunityServices = CommunityServiceBc.Instance.GetDefaultCommunityServices();

            communityDetails.DefaultCommunityServices = CommunityExtentions.GetDefaultCommunityServices(community.CommunityServices, defaultCommunityServices);
            communityDetails.CustomCommunityServices  = CommunityExtentions.GetCustomCommunityServices(community.CommunityServices, defaultCommunityServices);
            communityDetails.Images      = community.Images.MapToImageListVm(DisplayNames.CommunityImages);
            communityDetails.LogoImages  = community.LogoImages.MapToImageListVm(DisplayNames.CommunityLogo);
            communityDetails.VirtualTour = community.VirtualTour;
            communityDetails.Coupon      = (community.Coupon != null ? community.Coupon.MapToCouponVm() : new CouponVm());
            if (community.FloorPlans == null || !community.FloorPlans.Any <FloorPlan>())
            {
                communityDetails.HasFloorPlans = false;
                communityDetails.FloorPlans    = new List <FloorPlanVm>()
                {
                    AdminViewModelsProvider.GetCommunityUnit(CommunityUnitType.FloorPlan)
                };
            }
            else
            {
                communityDetails.HasFloorPlans = community.FloorPlans.Any <FloorPlan>();
                communityDetails.FloorPlans    = community.FloorPlans.MapToFloorPlanVmList();
            }
            if (community.SpecHomes == null || !community.SpecHomes.Any <SpecHome>())
            {
                communityDetails.HasSpecHomes = false;
                communityDetails.SpecHomes    = new List <SpecHomeVm>()
                {
                    AdminViewModelsProvider.GetCommunityUnit(CommunityUnitType.SpecHome)
                };
            }
            else
            {
                communityDetails.HasSpecHomes = community.SpecHomes.Any <SpecHome>();
                communityDetails.SpecHomes    = community.SpecHomes.MapToSpecHomeVmList();
            }
            if (community.Houses == null || !community.Houses.Any <House>())
            {
                communityDetails.HasHouses = false;
                communityDetails.Houses    = new List <HouseVm>()
                {
                    AdminViewModelsProvider.GetHouseUnit()
                };
            }
            else
            {
                communityDetails.HasHouses = community.Houses.Any <House>();
                communityDetails.Houses    = community.Houses.MapToHouseVmList();
            }
            return(communityDetails);
        }
예제 #25
0
        public async Task <APEntity> GetEntity(string id, bool doRemote)
        {
            if (id == "https://www.w3.org/ns/activitystreams#Public")
            {
                var aso = new ASObject();
                aso.Type.Add("https://www.w3.org/ns/activitystreams#Collection");
                aso.Id = "https://www.w3.org/ns/activitystreams#Public";

                var ent = APEntity.From(aso);
                return(ent);
            }
            string origin = id;

            try {
                var uri = new Uri(id);
                if (uri.Host == "localhost")
                {
                    return(await Bypass.GetEntity(id, doRemote));
                }
                origin = uri.GetLeftPart(UriPartial.Authority);
            } catch (UriFormatException) { /* nom */ }

            APEntity entity = null;

            if (Bypass != null)
            {
                entity = await Bypass.GetEntity(id, doRemote);
            }

/*            if (entity == null)
 *          {
 *              var possibilities = (await _getRE().Query(new RelevantEntitiesService.ContainsAnyStatement("https://www.w3.org/ns/activitystreams#url") { id })).Where(a => Uri.IsWellFormedUriString(a.Id, UriKind.Absolute) && (new Uri(a.Id)).GetLeftPart(UriPartial.Authority) == origin).ToList();
 *              if (possibilities.Count == 1) entity = possibilities.First();
 *          }*/
            if (entity != null && !entity.IsOwner && entity.Data.Type.Any(_collections.Contains) && doRemote)
            {
                entity = null;
            }
            if (entity != null || !doRemote)
            {
                return(entity);
            }

            var htc     = new HttpClient();
            var request = new HttpRequestMessage(HttpMethod.Get, id);

            request.Headers.TryAddWithoutValidation("Accept", "application/activity+json; application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\", application/json, text/html");

            if (_context != null)
            {
                var signatureVerifier = _serviceProvider.GetRequiredService <SignatureVerifier>();
                var user = await Bypass.GetEntity(_context.User.FindFirstValue("actor"), false);

                if (user != null)
                {
                    var jwt = await signatureVerifier.BuildJWS(user, id);

                    if (jwt != null)
                    {
                        request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", jwt);
                    }
                    request.Headers.TryAddWithoutValidation("Signature", await _keyService.BuildHTTPSignature(user.Id, request));
                }
            }

            HttpResponseMessage response = null;

            try
            {
                response = await htc.SendAsync(request);
            }
            catch (TaskCanceledException)
            {
                return(null); // timeout
            }
            catch (HttpRequestException)
            {
                return(null);
            }

            ASObject data = null;
            await response.Content.LoadIntoBufferAsync();

            foreach (var converter in ServerConfig.Converters)
            {
                if (converter.CanParse && ConverterHelpers.GetBestMatch(converter.MimeTypes, response.Content.Headers.ContentType.ToString()) != null)
                {
                    try {
                        data = await converter.Build(_serviceProvider, null).Parse(await response.Content.ReadAsStreamAsync());

                        break;
                    } catch (NullReferenceException e) { Console.WriteLine(e); /* nom */ }
                }
            }

            if (data == null)
            {
                return(null);
            }

            // forces out the old lazy load, if used
            await _entityFlattener.FlattenAndStore(Bypass, data, false);

            return(await Bypass.GetEntity(id, true));
        }
예제 #26
0
        public virtual Community ToEntity()
        {
            long      id;
            Community community = new Community()
            {
                Book = new Book()
                {
                    Id = this.BookId
                },
                Package      = this.Package,
                ListingTypes = ConverterHelpers.CheckBoxListToEnumList <ListingType>(this.ListingTypes),
                SeniorHousingAndCareCategoryIds = ConverterHelpers.CheckBoxListToLongArray(this.SeniorHousingAndCareCategories),
                AgeRestrictions = ConverterHelpers.CheckBoxListToEnumList <AgeRestriction>(this.AgeRestrictions),
                Name            = this.Name,
                Address         = (this.AddressValidation.ValidationItems == null ? this.Address.ToEntity() : this.AddressValidation.ToEntity()),
                DisplayAddress  = !this.DoNotDisplayAddress,
                Phones          = this.PhoneList.ToEntityList(),
                Emails          = this.EmailList.ToEntity(),
                Contacts        = this.Contacts.ConvertAll <Contact>((ContactVm m) => m.ToEntity()).Where <Contact>((Contact x) => {
                    if (!string.IsNullOrWhiteSpace(x.FirstName))
                    {
                        return(true);
                    }
                    return(!string.IsNullOrWhiteSpace(x.LastName));
                }).ToList <Contact>(),
                OfficeHours = (
                    from m in this.OfficeHours
                    select m.ToEntity()).ToList <MSLivingChoices.Entities.Admin.OfficeHours>(),
                Description       = this.Description,
                WebsiteUrl        = MslcUrlBuilder.NormalizeUri(this.WebsiteUrl),
                DisplayWebsiteUrl = this.DisplayWebsiteUrl
            };
            List <long> paymentTypeIds = new List <long>();

            foreach (CheckBoxVm checkBoxVm in
                     from m in this.CommunityDetails.PaymentTypes
                     where m.IsChecked
                     select m)
            {
                if (!long.TryParse(checkBoxVm.Value, out id))
                {
                    continue;
                }
                paymentTypeIds.Add(id);
            }
            community.PaymentTypeIds    = paymentTypeIds;
            community.PriceRange        = this.CommunityDetails.PriceRange.ToEntity();
            community.Deposit           = this.CommunityDetails.Deposit.ToEntity();
            community.ApplicationFee    = this.CommunityDetails.ApplicationFee.ToEntity();
            community.PetDeposit        = this.CommunityDetails.PetDeposit.ToEntity();
            community.BedroomFromId     = this.CommunityDetails.BedroomFromId;
            community.BedroomToId       = this.CommunityDetails.BedroomToId;
            community.BathroomFromId    = this.CommunityDetails.BathroomFromId;
            community.BathroomToId      = this.CommunityDetails.BathroomToId;
            community.LivingSpace       = this.CommunityDetails.LivingSpace.ToEntity();
            community.UnitCount         = this.CommunityDetails.UnitCount;
            community.Amenities         = AmenityVm.ToEntityList(this.CommunityDetails.DefaultAmenities, this.CommunityDetails.CustomAmenities);
            community.CommunityServices = CommunityServiceVm.ToEntityList(this.CommunityDetails.DefaultCommunityServices, this.CommunityDetails.CustomCommunityServices);
            community.FloorPlans        = new List <FloorPlan>();
            community.SpecHomes         = new List <SpecHome>();
            community.Houses            = new List <House>();
            community.VirtualTour       = MslcUrlBuilder.NormalizeUri(this.CommunityDetails.VirtualTour);
            community.Coupon            = this.CommunityDetails.Coupon.ToEntity();
            community.Images            = (this.CommunityDetails.Images == null ? new List <Image>() : this.CommunityDetails.Images.ToEntity(ImageType.Photo));
            community.LogoImages        = (this.CommunityDetails.LogoImages == null ? new List <Image>() : this.CommunityDetails.LogoImages.ToEntity(ImageType.Logo));
            if (this.CommunityDetails.HasFloorPlans)
            {
                community.FloorPlans = (
                    from m in this.CommunityDetails.FloorPlans
                    select m.ToEntity()).ToList <FloorPlan>();
                community.FloorPlans.ForEach((FloorPlan m) => m.Community = community);
            }
            if (this.CommunityDetails.HasSpecHomes)
            {
                community.SpecHomes = (
                    from m in this.CommunityDetails.SpecHomes
                    select m.ToEntity()).ToList <SpecHome>();
                community.SpecHomes.ForEach((SpecHome m) => m.Community = community);
            }
            if (this.CommunityDetails.HasHouses)
            {
                community.Houses = (
                    from m in this.CommunityDetails.Houses
                    select m.ToEntity()).ToList <House>();
                community.Houses.ForEach((House m) => m.Community = community);
            }
            community.PropertyManager    = this.ListingDetails.PropertyManager.ToEntity(OwnerType.PropertyManager);
            community.Builder            = this.ListingDetails.Builder.ToEntity(OwnerType.Builder);
            community.CallTrackingPhones = new List <CallTrackingPhone>();
            if (this.ListingDetails.CallTrackingPhones != null)
            {
                if (!this.ListingDetails.ProvisionCallTrackingNumbers)
                {
                    this.ListingDetails.CallTrackingPhones.ForEach((CallTrackingPhoneVm c) => c.IsDisconnected = true);
                }
                community.CallTrackingPhones = (
                    from p in this.ListingDetails.CallTrackingPhones.ConvertAll <CallTrackingPhone>((CallTrackingPhoneVm x) => x.ToEntity())
                    where !string.IsNullOrEmpty(p.Phone)
                    select p).ToList <CallTrackingPhone>();
            }
            community.Publishing.StartDate = this.PublishStart;
            community.Publishing.EndDate   = this.PublishEnd;
            community.Showcase.StartDate   = this.ShowcaseStart;
            community.Showcase.EndDate     = this.ShowcaseEnd;
            return(community);
        }
예제 #27
0
        public async Task <APEntity> GetEntity(string id, bool doRemote)
        {
            if (id == "https://www.w3.org/ns/activitystreams#Public")
            {
                var aso = new ASObject();
                aso.Type.Add("https://www.w3.org/ns/activitystreams#Collection");
                aso.Id = "https://www.w3.org/ns/activitystreams#Public";

                var ent = APEntity.From(aso);
                return(ent);
            }
            try {
                if ((new Uri(id)).Host == "localhost")
                {
                    return(await Bypass.GetEntity(id, doRemote));
                }
            } catch (UriFormatException) { /* nom */ }

            APEntity entity = null;

            if (Bypass != null)
            {
                entity = await Bypass.GetEntity(id, doRemote);
            }
            if (entity != null && !entity.IsOwner && entity.Data.Type.Any(_collections.Contains) && doRemote)
            {
                entity = null;
            }

            if (entity?.Type == "_:LazyLoad" && !doRemote)
            {
                return(null);
            }
            if ((entity != null && entity.Type != "_:LazyLoad") || !doRemote)
            {
                return(entity);
            }

            var loadUrl = id;

            if (entity?.Type == "_:LazyLoad")
            {
                loadUrl = (string)entity.Data["href"].First().Primitive;
            }

            if (loadUrl.StartsWith("tag:"))
            {
                return(null);
            }

            var htc = new HttpClient();

            htc.DefaultRequestHeaders.TryAddWithoutValidation("Accept", "application/activity+json; application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\", application/json, application/atom+xml, text/html");

            if (_context != null)
            {
                var signatureVerifier = _serviceProvider.GetRequiredService <SignatureVerifier>();
                var user = await Bypass.GetEntity(_context.User.FindFirstValue(JwtTokenSettings.ActorClaim), false);

                if (user != null)
                {
                    var jwt = await signatureVerifier.BuildJWS(user, id);

                    if (jwt != null)
                    {
                        htc.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", jwt);
                    }
                }
            }

            HttpResponseMessage response = null;

            try
            {
                response = await htc.GetAsync(loadUrl);

                if (!response.IsSuccessStatusCode)
                {
                    response = await htc.GetAsync(loadUrl + ".atom"); // hack!

                    if (!response.IsSuccessStatusCode)
                    {
                        return(null);
                    }
                }
            }
            catch (TaskCanceledException)
            {
                return(null); // timeout
            }
            catch (HttpRequestException)
            {
                return(null);
            }

            var converters = new List <IConverterFactory> {
                new AS2ConverterFactory(), new AtomConverterFactory(false)
            };

tryAgain:
            ASObject data = null;

            foreach (var converter in converters)
            {
                if (converter.CanParse && ConverterHelpers.GetBestMatch(converter.MimeTypes, response.Content.Headers.ContentType.ToString()) != null)
                {
                    data = await converter.Build(_serviceProvider, null).Parse(await response.Content.ReadAsStreamAsync());

                    break;
                }
            }

            if (data == null)
            {
                if (response.Headers.Contains("Link"))
                {
                    var split = string.Join(", ", response.Headers.GetValues("Link")).Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
                    foreach (var spl in split)
                    {
                        var args = spl.Split(';').Select(a => a.Trim()).ToArray();
                        if (args.Contains("rel=\"alternate\"") && args.Contains("type=\"application/atom+xml\""))
                        {
                            response = await htc.GetAsync(args[0].Substring(1, args[0].Length - 2));

                            goto tryAgain;
                        }
                    }
                }

                try
                {
                    var links = (await response.Content.ReadAsStringAsync()).Split('\n');
                    var alt   = links.FirstOrDefault(a => a.Contains("application/atom+xml") && a.Contains("alternate"));
                    if (alt == null)
                    {
                        return(null);
                    }
                    var l = XDocument.Parse(alt + "</link>").Root;
                    if (l.Attribute(XNamespace.None + "type")?.Value == "application/atom+xml")
                    {
                        response = await htc.GetAsync(l.Attribute(XNamespace.None + "href")?.Value);

                        goto tryAgain;
                    }
                }
                catch (Exception) { }

                return(null);
            }

            // forces out the old lazy load, if used
            await _entityFlattener.FlattenAndStore(Bypass, data, false);

            return(await Bypass.GetEntity(id, true));
        }