Ejemplo n.º 1
0
 public ArtistModule()
     : base("/artist")
 {
     var mappingService = new MappingService(new LastFmLoader(), "artists");
     Get["/"] = _ => MapUsing(mappingService);
     Post["/"] = _ => MapUsing(mappingService);
 }
Ejemplo n.º 2
0
 public AlbumModule()
     : base("/album")
 {
     var mappingService = new MappingService(new LastFmLoader(), "albums");
     Get["/"] = _ => MapUsing(mappingService);
     Post["/"] = _ => MapUsing(mappingService);
 }
Ejemplo n.º 3
0
 public TrackModule()
     : base("/track")
 {
     var mappingService = new MappingService(new LastFmLoader(), "tracks");
     Get["/"] = _ => MapUsing(mappingService);
     Post["/"] = _ => MapUsing(mappingService);
 }
 public void ServiceLoadsFromFile()
 {
     var loader = new Mock<ILoader>();
     var subject = new MappingService(loader.Object, "tracks");
     var result = subject.Map(new Mapping());
     loader.Verify( l => l.Load(It.IsAny<string>()));
 }
Ejemplo n.º 5
0
        private Response MapUsing(MappingService mappingService)
        {
            var result = mappingService.Map(Mapping.From(this.Bind<SerializableMapping>()));

            var viewmodel = new SerializableMapping();
            return Response.AsJson(result.To(viewmodel));
        }
Ejemplo n.º 6
0
        public void Setup()
        {
            _cuisinesDataSetup = new List<LookupRestaurantType>
            {
                new LookupRestaurantType {Id = 1, Type = "American"}
            };

            _lookupTaskMock = new Mock<ILookupTask>();
            _lookupTaskMock.Setup(p => p.GetCuisines()).Returns(_cuisinesDataSetup);

            _mappingService = new MappingService();
            _lookupController = new LookupController(_lookupTaskMock.Object, _mappingService);
        }
        public ActionResult AreaEdit(Guid id)
        {
            //-- TODO Put error check
            var area = geoSvc.GetAreaByID(id);
            if (area == null) { return new PlacesController().PlaceNotFound(); }

            ViewBag.Area = area;

            var geoJsonUrl = Stgs.MapSvcRelativeUrl + "area/" + id.ToString();
            var mapModel = new Bing7GeoJsonMapViewModel("climbing-map-" + id, 680, 400, geoJsonUrl);
            mapModel.ViewOptions = new Bing7MapViewOptionsViewModel(mappingSvc.GetBingViewByID(area.ID));

            ViewBag.PlaceTypeDropDownList = cf.Web.Mvc.ViewData.SelectLists.GetAreaTypeSelectList(false);

            ViewBag.MapImageToDisplayUrl = (area.AvatarRelativeUrl != string.Empty)
                ? Stgs.ImgsRt + area.AvatarRelativeUrl
                : Stgs.DefaultMapInfoImage;

            var mapItems = new MappingService().GetAreaEditMapItems(area);
            ViewBag.MapItemsArea = mapItems.Items[0];
            mapItems.Items.RemoveAt(0);
            ViewBag.MapItemsLocations = mapItems.Items;

            return View(new AreaEditViewModel()
            {
                ID = area.ID,
                WKT = area.Geo.GetWkt(),
                GeoReduceThreshold = area.GeoReduceThreshold,
                SearchSupportString = area.SearchSupportString,
                PlaceType = area.Type.ToString(),
                Name = area.Name,
                NameShort = area.NameShort,
                NameUrlPart = area.NameUrlPart,
                Description = area.Description,
                NoIndoorConfirmed = area.NoIndoorConfirmed,
                MapModel = mapModel
            });
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Search for IncidentType items
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="searchCriteria"></param>
        /// <param name="page"></param>
        /// <param name="pageSize"></param>
        /// <param name="includeInActive"></param>
        /// <returns></returns>
        public IncidentTypeSearchVMDC SearchIncidentType(string currentUser, string user, string appID, string overrideID, IncidentTypeSearchCriteriaDC searchCriteria, int page, int pageSize, bool includeInActive)
        {
            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            IRepository <IncidentType> dataRepository = new Repository <IncidentType>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create specification for filtering
            ISpecification <IncidentType> specification = new Specification <IncidentType>();

            // Create isActive specification
            ISpecification <IncidentType> isActiveSpecification = new IsActiveSpecification <IncidentType>();

            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Call overload with injected objects
            return(SearchIncidentType(currentUser, user, appID, overrideID, searchCriteria, page, pageSize, includeInActive, specification, isActiveSpecification, dataRepository, uow, exceptionManager, mappingService));
        }
Ejemplo n.º 9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="includeInActive"></param>
        /// <returns></returns>
        public List <OrganisationDC> GetAllOrganisation(string currentUser, string user, string appID, string overrideID, bool includeInActive)
        {
            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            Repository <Organisation> dataRepository = new Repository <Organisation>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create specification for filtering
            ISpecification <Organisation> specification = new Specification <Organisation>();

            // Create isActive specification
            ISpecification <Organisation> isActiveSpecification = new IsActiveSpecification <Organisation>();

            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Call overload with injected objects
            return(GetAllOrganisation(currentUser, user, appID, overrideID, includeInActive, specification, isActiveSpecification, dataRepository, uow, exceptionManager, mappingService));
        }
Ejemplo n.º 10
0
        public MappingModule()
        {
            var mappingService = new MappingService(new LastFmLoader(), "tracks");
            Get["/mbid/{Mbid}"] = req =>
                                  {
                                      var result = mappingService.Map(new Mapping { MusicBrainz = new MusicBrainzId(req.Mbid) });

                                      return((Mapping) result).SevenDigital.ToString();
                                  };

            Get["/7did/{Id}"] = req =>
            {
                                    var result = mappingService.Map(new Mapping { SevenDigital = new SevenDigitalId(req.Id) });
                                    return
                                      Response.AsRedirect(
                                          "http://www.last.fm/mbid/"
                                          +
                                          ((Mapping)result).MusicBrainz.ToString
                                              ());

                                };
            Get["/status"] = _ => DateTime.Now.ToString();
        }
        private Area PrepareViewDataForLocationOutdoorNew(string countryUrlPart, string areaNameUrlPart)
        {
            var area = geoSvc.GetArea(country.ID, areaNameUrlPart);

            if (area == default(Area))
            {
                return(default(Area));
            }
            ViewBag.Area = area;

            List <Location> locationsOfTypeAlreadyInArea = geoSvc.GetLocationsOfArea(area.ID).Where(
                a => a.Type.ToPlaceCateogry() == PlaceCategory.OutdoorClimbing).ToList();

            ViewBag.ExistingLocations = locationsOfTypeAlreadyInArea;

            var mapItems = new MappingService().GetAreaEditMapItems(area);

            ViewBag.MapItemsArea = mapItems.Items[0];
            mapItems.Items.RemoveAt(0);
            ViewBag.MapItemsLocations = mapItems.Items;

            return(area);
        }
Ejemplo n.º 12
0
        public void Test_Calculate_AddOutputItem()
        {
            var input       = new Mock <IInput>();
            var listService = new Mock <IMappingListService>(MockBehavior.Strict);

            listService
            .Setup(s => s.GetList())
            .Returns(new List <Type>());
            var filteredMappings = new List <IMappingBase>
            {
                new Mock <IMappingBase>().Object,
                new Mock <IMappingBase>().Object
            };
            var filterService = new Mock <IMappingFilterService>(MockBehavior.Strict);

            filterService
            .Setup(s => s.Filter(It.IsAny <IList <Type> >(), It.IsAny <IInput>()))
            .Returns(filteredMappings);
            var output = new Mock <IOutput>();

            output
            .Setup(s => s.AddOutputItem(It.IsAny <XEnum>(), It.IsAny <decimal>(), It.IsAny <string>()));
            var factory = new Mock <IOutputFactory>();

            factory.Setup(s => s.Create())
            .Returns(output.Object);

            var service = new MappingService(listService.Object, filterService.Object, factory.Object);
            var result  = service.Calculate(input.Object);

            listService.Verify(v => v.GetList(), Times.Once());
            filterService.Verify(v => v.Filter(It.IsAny <IList <Type> >(), It.IsAny <IInput>()), Times.Once());
            factory.Verify(v => v.Create(), Times.Once());
            output.Verify(v => v.AddOutputItem(It.IsAny <XEnum>(), It.IsAny <decimal>(), It.IsAny <string>()),
                          Times.Exactly(filteredMappings.Count));
            Assert.AreEqual(output.Object, result);
        }
Ejemplo n.º 13
0
        public void GetServicesOfNullReturnsKnownServices()
        {
            MappingService[] ss = MappingService.GetServices(null);

            Guid[] guids = new Guid[] {
                MappingAvailableServices.LanguageDetection,
                MappingAvailableServices.ScriptDetection,
                MappingAvailableServices.TransliterationBengaliToLatin,
                MappingAvailableServices.TransliterationCyrillicToLatin,
                MappingAvailableServices.TransliterationDevanagariToLatin,
                MappingAvailableServices.TransliterationHansToHant,
                MappingAvailableServices.TransliterationHantToHans,
                MappingAvailableServices.TransliterationMalayalamToLatin
            };

            foreach (MappingService s in ss)
            {
                Assert.True(s.BuildVersion >= 0);
                Assert.NotEqual <string>(s.Category, String.Empty);
                Assert.NotEqual <string>(s.Category, "");
                Assert.NotNull(s.Category);

                Assert.NotEqual <string>(s.Copyright, String.Empty);
                Assert.NotEqual <string>(s.Copyright, "");
                Assert.NotNull(s.Copyright);

                Assert.NotEqual <string>(s.Description, String.Empty);
                Assert.NotEqual <string>(s.Description, "");
                Assert.NotNull(s.Description);

                Assert.Contains <Guid>(s.Guid, guids);

                Assert.NotEmpty(s.InputContentTypes);
                Assert.True(s.MajorVersion >= 0 && s.MinorVersion >= 0);
                Assert.NotEmpty(s.OutputContentTypes);
            }
        }
        public void ShouldReturnTransactionsBetweenTheGivenDateRange()
        {
            var dbQueryResult = new List <Transaction>();

            var dataContextConfig = new Mock <DataContext>();

            var mappingConfigs    = new IMappingConfiguration[] { new TransactionToGetAllTransactionsResponseModelMappingConfiguration() };
            var mappingService    = new MappingService(mappingConfigs);
            var validationService = new ValidationService();

            var transactionsQueryable       = _transactions.AsQueryable();
            var transactionsDbSetMockConfig = new Mock <DbSet <Transaction> >();

            transactionsDbSetMockConfig.As <IQueryable <Transaction> >().Setup(mockSetup => mockSetup.Provider).Returns(new CustomizedQueryProvider(transactionsQueryable.Provider, new Action <string, Expression, EnumerableQuery <Transaction> >((methodName, expression, result) =>
            {
                dbQueryResult = result.ToList();
            })));
            transactionsDbSetMockConfig.As <IQueryable <Transaction> >().Setup(mockSetup => mockSetup.Expression).Returns(transactionsQueryable.Expression);
            transactionsDbSetMockConfig.As <IQueryable <Transaction> >().Setup(mockSetup => mockSetup.ElementType).Returns(transactionsQueryable.ElementType);
            transactionsDbSetMockConfig.As <IQueryable <Transaction> >().Setup(mockSetup => mockSetup.GetEnumerator()).Returns(() => transactionsQueryable.GetEnumerator());

            var dbContextOptions = new DbContextOptionsBuilder <DataContext>()
                                   .UseInMemoryDatabase(databaseName: "Test")
                                   .Options;

            var dataContextMockConfig = new Mock <DataContext>(dbContextOptions);

            dataContextMockConfig.SetupGet(mockSetup => mockSetup.Transactions).Returns(() => transactionsDbSetMockConfig.Object);

            var transactionManager = new TransactionManager(dataContextMockConfig.Object, validationService, mappingService);

            var begin = new DateTime(2021, 5, 9);
            var end   = new DateTime(2021, 5, 11);

            transactionManager.GetAllTransactionsByDateRange(begin, end);
            Assert.IsTrue(dbQueryResult.All(transaction => transaction.TransactionDate >= begin && transaction.TransactionDate <= end));
        }
Ejemplo n.º 15
0
        public ActionResult UpdateNews(int newsid = 11)
        {
            if (Session["account"] is null)
            {
                return(RedirectToAction("Login", "Login"));
            }
            else
            {
                var account              = Session["account"] as Account;
                NewspaperService svn     = new NewspaperService();
                var            result    = svn.GetById(newsid);
                MappingService svm       = new MappingService();
                var            mapresult = svm.GetAll().Where(x => x.NewsId == result.NewsId).ToList();
                List <Topic>   lsttopic  = new List <Topic>();
                TopicService   svt       = new TopicService();
                foreach (var item in mapresult)
                {
                    lsttopic.Add(svt.GetById(item.TopicId));
                }
                string str = "";
                foreach (var item in lsttopic)
                {
                    str += item.TopicId + ",";
                }
                str = str.Substring(0, str.Length - 1);

                ViewBag.GetTopic = str;
                NewInfo newinfo = new NewInfo();
                newinfo.Title       = result.Title;
                newinfo.NewsId      = result.NewsId;
                newinfo.Image       = result.Image;
                newinfo.Journalist  = account.AccountName;
                newinfo.Description = result.Description;
                newinfo.Topic       = svt.GetAll().ToList();
                return(View(newinfo));
            }
        }
        /// <summary>
        /// Retrieve a OrganisationHierarchy with associated lookups
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="code"></param>
        /// <returns></returns>
        public OrganisationHierarchyVMDC GetOrganisationHierarchy(string currentUser, string user, string appID, string overrideID, string code)
        {
            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            IRepository <OrganisationHierarchy> dataRepository = new Repository <OrganisationHierarchy>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create repositories for lookup data
            IRepository <Organisation> ancestorOrganisationRepository = new Repository <Organisation>(uow.ObjectContext, currentUser, user, appID, overrideID);
            IRepository <Organisation> organisationRepository         = new Repository <Organisation>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Call overload with injected objects
            return(GetOrganisationHierarchy(currentUser, user, appID, overrideID, code, uow, dataRepository
                                            , ancestorOrganisationRepository
                                            , organisationRepository
                                            , exceptionManager, mappingService));
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Retrieve a SiteStaff with associated lookups
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="code"></param>
        /// <returns></returns>
        public SiteStaffVMDC GetSiteStaff(string currentUser, string user, string appID, string overrideID, string code)
        {
            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            IRepository <SiteStaff> dataRepository = new Repository <SiteStaff>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create repositories for lookup data
            IRepository <Site>  siteRepository  = new Repository <Site>(uow.ObjectContext, currentUser, user, appID, overrideID);
            IRepository <Staff> staffRepository = new Repository <Staff>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Call overload with injected objects
            return(GetSiteStaff(currentUser, user, appID, overrideID, code, uow, dataRepository
                                , siteRepository
                                , staffRepository
                                , exceptionManager, mappingService));
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Retrieve a LinkedCustomer with associated lookups
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="code"></param>
        /// <returns></returns>
        public LinkedCustomerVMDC GetLinkedCustomer(string currentUser, string user, string appID, string overrideID, string code)
        {
            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            IRepository <LinkedCustomer> dataRepository = new Repository <LinkedCustomer>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create repositories for lookup data
            IRepository <Customer> customer1Repository = new Repository <Customer>(uow.ObjectContext, currentUser, user, appID, overrideID);
            IRepository <Customer> customer2Repository = new Repository <Customer>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Call overload with injected objects
            return(GetLinkedCustomer(currentUser, user, appID, overrideID, code, uow, dataRepository
                                     , customer1Repository
                                     , customer2Repository
                                     , exceptionManager, mappingService));
        }
        public void ShouldMapFrameworkProvidersItemToViewModel()
        {
            var service = new MappingService(Mock.Of <ILog>());

            var response = new ProviderSearchResultItem
            {
                Address = new Address {
                    Address1 = "Address 1", County = "Angleterre"
                },
                LocationName  = "Location Name",
                LocationId    = 12345,
                DeliveryModes = new List <string> {
                    "100PercentEmployer", "DayRelease"
                }
            };

            var viewModel = service.Map <ProviderSearchResultItem, FrameworkProviderResultItemViewModel>(response);

            viewModel.Should().NotBeNull();
            viewModel.LocationAddressLine.Should().Be("Location Name, Address 1, Angleterre");
            viewModel.DeliveryModes.Count(x => x.Contains("100PercentEmployer")).Should().Be(1);
            viewModel.DeliveryModes.Count(x => x.Contains("DayRelease")).Should().Be(1);
            viewModel.DeliveryModes.Count.Should().Be(2);
        }
Ejemplo n.º 20
0
        public ScopeDto AddOrUpdateScope(ScopeDto scopeDto)
        {
            ScopeDto updatedScopeDto = null;

            Execute(uow =>
            {
                var scope = uow.Store.AddOrUpdate(MappingService.Map <Scope>(scopeDto).AsNewEntity(),
                                                  x => x.Name == scopeDto.Name);
                updatedScopeDto = MappingService.Map <ScopeDto>(scope);

                if (scopeDto.ScopeClaims != null)
                {
                    foreach (var scopeClaim in
                             scopeDto.ScopeClaims.Select(
                                 scopeClaimDto => MappingService.Map <ScopeClaim>(scopeClaimDto).WithScope(scope)))
                    {
                        uow.Store.AddOrUpdate(scopeClaim, x => x.Name == scopeClaim.Name);
                    }
                }

                if (scopeDto.ScopeSecrets != null)
                {
                    foreach (var scopeSecret in
                             scopeDto.ScopeSecrets.Select(
                                 scopeSecretDto => MappingService.Map <ScopeSecret>(scopeSecretDto).WithScope(scope)))
                    {
                        uow.Store.AddOrUpdate(scopeSecret, x => x.Type == scopeSecret.Type);
                    }
                }

                CollectScopeAssociatedInfo(uow, updatedScopeDto);
                uow.Cache.HashSetAsync(KeyToScopeHash, updatedScopeDto.Name, Serializer.Serialize(updatedScopeDto))
                .Wait();
            });
            return(updatedScopeDto);
        }
Ejemplo n.º 21
0
        private List <RealEstate> GetRoomIds([FromBody] ParamsModel RealEstateNos)
        {
            if (RealEstateNos == null || RealEstateNos.RealEstateNos.Length == 0)
            {
                return(new List <RealEstate>());
            }
            List <RealEstate> mappings = new List <RealEstate>();

            foreach (var item in RealEstateNos.RealEstateNos)
            {
                MappingService mappingService = new MappingService();
                var            mapping        = _realEstateService.GetHouseHold(item);
                mappings.Add(mapping);
            }
            if (mappings.Count == 0)
            {
                return(new List <RealEstate>());
            }

            else
            {
                return(mappings);
            }
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Retrieve a IncidentInterestedParty with associated lookups
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="code"></param>
        /// <returns></returns>
        public IncidentInterestedPartyVMDC GetIncidentInterestedParty(string currentUser, string user, string appID, string overrideID, string code)
        {
            //Create ExceptionManager
            IExceptionManager exceptionManager = new ExceptionManager();

            //Create MappingService
            IMappingService mappingService = new MappingService();

            // Create unit of work
            IUnitOfWork uow = new UnitOfWork(currentUser);

            // Create repository
            IRepository <IncidentInterestedParty> dataRepository = new Repository <IncidentInterestedParty>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Create repositories for lookup data
            IRepository <Incident>        incidentRepository        = new Repository <Incident>(uow.ObjectContext, currentUser, user, appID, overrideID);
            IRepository <InterestedParty> interestedPartyRepository = new Repository <InterestedParty>(uow.ObjectContext, currentUser, user, appID, overrideID);

            // Call overload with injected objects
            return(GetIncidentInterestedParty(currentUser, user, appID, overrideID, code, uow, dataRepository
                                              , incidentRepository
                                              , interestedPartyRepository
                                              , exceptionManager, mappingService));
        }
Ejemplo n.º 23
0
        public static async Task <Tuple <List <Face>, List <User> > > Identify(string personGroupId, List <Face> faces, FaceIdentificationContext appContext)
        {
            var iReturn = new Tuple <List <Face>, List <User> >(faces, new List <User>());

            HttpClient client   = InitializeClient();
            string     facesIds = string.Join("\",\"", faces.Select(f => f.FaceID));

            List <identifyResponse> iResponse = new List <identifyResponse>();

            byte[] byteData = Encoding.UTF8.GetBytes("{\"personGroupId\":\"" + personGroupId + "\",\"faceIds\":[\"" + facesIds + "\"]}");


            using (var content = new ByteArrayContent(byteData))
            {
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                var response = await client.PostAsync(@baseURL + "/identify?maxNumOfCandidatesReturned=1", content);

                var responseString = await response.Content.ReadAsStringAsync();

                iResponse = JsonConvert.DeserializeObject <List <identifyResponse> >(responseString);
            }
            for (int i = 0; i < iResponse.Count; i++)
            {
                identifyResponse item = iResponse[i];
                if (item.Candidates.Count > 0)
                {
                    string personId = item.Candidates[0].PersonId;
                    string userId   = MappingService.GetFromMapping(appContext.AppID + "-" + appContext.Context.Id, personId);
                    User   user     = new User(userId, ""); //TODO:Change to retrive user name appContext.users[i].name);
                    iReturn.Item2.Add(user);                //appid-context, personid
                    iReturn.Item1.RemoveAt(i);
                }
            }

            return(iReturn);
        }
Ejemplo n.º 24
0
        public ActionResult Edit(PatientViewModel obj)
        {
            try
            {
                csPatient csPatient = new MappingService().Map <PatientViewModel, csPatient>(obj);

                var res = new DoctorController().Update_Patient(csPatient);

                if (res.status_code == 1)
                {
                    return(RedirectToAction("Details"));
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Oops something went wrong! ");
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError(string.Empty, ex.Message);
            }

            return(View(obj));
        }
Ejemplo n.º 25
0
        public MappingServiceTests()
        {
            var element = new ElementBuilder()
                          .WithType(EElementType.Textarea)
                          .WithQuestionId("test-question")
                          .Build();

            var page = new PageBuilder()
                       .WithElement(element)
                       .WithValidatedModel(true)
                       .WithPageSlug("page-one")
                       .Build();

            var schema = new FormSchemaBuilder()
                         .WithPage(page)
                         .Build();

            _mockSchemaProvider.Setup(_ => _.Get <FormSchema>(It.IsAny <string>()))
            .ReturnsAsync(schema);

            _mockDistrubutedCache.Setup(_ => _.GetString(It.IsAny <string>()))
            .Returns(JsonConvert.SerializeObject(new FormAnswers
            {
                Pages = new List <PageAnswers>()
            }));

            _mockDistributedCacheExpirationConfiguration.Setup(_ => _.Value).Returns(new DistributedCacheExpirationConfiguration
            {
                FormJson = 1
            });

            _mockSchemaFactory.Setup(_ => _.Build(It.IsAny <string>()))
            .ReturnsAsync(schema);

            _service = new MappingService(_mockDistrubutedCache.Object, _mockElementMapper.Object, _mockSchemaFactory.Object, _mockDistributedCacheExpirationConfiguration.Object, _mockLogger.Object);
        }
Ejemplo n.º 26
0
 public ActionResult UpdateNews(NewInfo info, FormCollection f)
 {
     if (Session["account"] is null)
     {
         return(RedirectToAction("Login", "Login"));
     }
     else
     {
         var              account   = Session["account"] as Account;
         var              listtopic = f["topicstring"].ToString().Split(new char[] { ',' });
         Newspaper        news      = new Newspaper();
         NewspaperService svn       = new NewspaperService();
         news.PublicationDate = DateTime.Now;
         news.Active          = 0;
         news.NewsId          = info.NewsId;
         news.Title           = info.Title;
         news.Image           = info.Image;
         news.Description     = info.Description;
         news.Journalist      = account.AccountName;
         svn.UpdateNewspaper(news);
         MappingService svm  = new MappingService();
         var            getm = svm.GetAll().Where(x => x.NewsId == news.NewsId);
         var            s    = getm.ToList().Count;
         foreach (var item in getm.ToList())
         {
             svm.DeleteMapping(item.MappingId);
         }
         foreach (var item in listtopic)
         {
             svm.AddMapping(new Mapping {
                 NewsId = info.NewsId, TopicId = Int32.Parse(item)
             });
         }
         return(RedirectToAction("UpdateNews"));
     }
 }
        private Area PrepareViewDataForLocationOutdoorNew(string countryUrlPart, string areaNameUrlPart)
        {
            var area = geoSvc.GetArea(country.ID, areaNameUrlPart);
            if (area == default(Area)) { return default(Area); }
            ViewBag.Area = area;

            List<Location> locationsOfTypeAlreadyInArea = geoSvc.GetLocationsOfArea(area.ID).Where(
              a => a.Type.ToPlaceCateogry() == PlaceCategory.OutdoorClimbing).ToList();

            ViewBag.ExistingLocations = locationsOfTypeAlreadyInArea;

            var mapItems = new MappingService().GetAreaEditMapItems(area);
            ViewBag.MapItemsArea = mapItems.Items[0];
            mapItems.Items.RemoveAt(0);
            ViewBag.MapItemsLocations = mapItems.Items;

            return area;
        }
Ejemplo n.º 28
0
        private void UpdateCoins(string cryptoCompareResponse, string cryptoCompareCoinsResponse, string coinMarketCapResponse, List <CoinConfig> coinConfigs)
        {
            List <CoinConfig> removeConfigs        = new List <CoinConfig>();
            decimal           totalPaid            = 0;
            decimal           totalOverall         = 0;
            decimal           totalNegativeProfits = 0;
            decimal           totalPostivieProfits = 0;
            int lineIndex = 0;

            if (string.IsNullOrWhiteSpace(cryptoCompareResponse) || string.IsNullOrWhiteSpace(cryptoCompareCoinsResponse) || string.IsNullOrWhiteSpace(coinMarketCapResponse))
            {
                MessageBox.Show("The API webservice is having issues at the moment. Please try again in a few minutes.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Application.Exit();
            }

            _coinNames = MappingService.CryptoCompareCoinList(cryptoCompareCoinsResponse);
            _coins     = MappingService.MapCombination(cryptoCompareResponse, coinMarketCapResponse, coinConfigs);

            MainService.CheckAlerts(_coins);

            if (_loadLines)
            {
                _cleanReset = true;
                RemoveLines();
            }

            foreach (CoinConfig coinConfig in coinConfigs)
            {
                if (!_coins.Any(c => c.ShortName == coinConfig.Name))
                {
                    Task.Factory.StartNew(() => { MessageBox.Show($"Sorry, Crypto Compare and Coin Market Cap does not have any data for {coinConfig.Name}."); });
                    removeConfigs.Add(coinConfig);
                    continue;
                }
                Coin coin = _coins.Find(c => c.ShortName == coinConfig.Name);

                if ((_cleanReset && _loadLines) || (!_coinLines.Any(c => c.CoinName.ExtEquals(coin.ShortName) && c.CoinIndex == coinConfig.Index)))
                {
                    if (_resetStartupPrice)
                    {
                        coinConfig.StartupPrice = 0;
                    }

                    AddLine(coinConfig, coin, lineIndex);
                }

                lineIndex++;

                CoinLine line = (from c in _coinLines where c.CoinName.ExtEquals(coin.ShortName) && c.CoinIndex == coinConfig.Index select c).First();

                decimal bought = line.BoughtTextBox.Text.ConvertToDecimal();
                decimal paid   = line.PaidTextBox.Text.ConvertToDecimal();
                decimal total  = bought * coin.Price;
                decimal profit = total - paid;

                coinConfig.Bought = bought;
                coinConfig.Paid   = paid;

                totalPaid    += paid;
                totalOverall += paid + profit;

                if (profit >= 0)
                {
                    totalPostivieProfits += profit;
                }
                else
                {
                    totalNegativeProfits += profit;
                }

                var coinIndexLabel     = coinConfigs.Count(c => c.Name.ExtEquals(coinConfig.Name)) > 1 ? $"[{coinConfig.Index + 1}]" : string.Empty;
                var coinLabel          = coin.ShortName;
                var priceLabel         = $"{MainService.CurrencySymbol}{coin.Price.ConvertToString(8)}";
                var boughtLabel        = $"{MainService.CurrencySymbol}{bought.SafeDivision(paid).ConvertToString(8)}";
                var totalLabel         = $"{MainService.CurrencySymbol}{total:0.00}";
                var profitLabel        = $"{MainService.CurrencySymbol}{profit:0.00}";
                var ratioLabel         = paid != 0 ? $"{profit / paid:0.00}" : "0.00";
                var changeDollarLabel  = $"{MainService.CurrencySymbol}{(coin.Price - coinConfig.StartupPrice):0.000000}";
                var changePercentLabel = $"{coinConfig.StartupPrice.SafeDivision(coin.Price - coinConfig.StartupPrice) * 100:0.00}%";
                var change1HrLabel     = $"{coin.Change1HourPercent:0.00}%";
                var change24HrLabel    = $"{coin.Change24HourPercent:0.00}%";
                var change7DayLabel    = $"{coin.Change7DayPercent:0.00}%";

                Invoke((MethodInvoker) delegate
                {
                    line.CoinIndexLabel.Text         = coinIndexLabel;
                    line.CoinLabel.Text              = coinLabel;
                    line.PriceLabel.Text             = priceLabel;
                    line.BoughtPriceLabel.Text       = boughtLabel;
                    line.TotalLabel.Text             = totalLabel;
                    line.ProfitLabel.Text            = profitLabel;
                    line.RatioLabel.Text             = ratioLabel;
                    line.ChangeDollarLabel.Text      = changeDollarLabel;
                    line.ChangePercentLabel.Text     = changePercentLabel;
                    line.Change1HrPercentLabel.Text  = change1HrLabel;
                    line.Change24HrPercentLabel.Text = change24HrLabel;
                    line.Change7DayPercentLabel.Text = change7DayLabel;
                });
            }

            //Remove unsupported coins
            foreach (var coinConfig in removeConfigs)
            {
                _coinConfigs.Remove(coinConfig);
            }

            if (_cleanReset)
            {
                _loadLines         = false;
                _resetStartupPrice = false;
            }

            _refreshTime = DateTime.Now;
            UpdateStatus("Sleeping");
            SetHeight(coinConfigs.Count);

            var totalProfitColor         = totalOverall - totalPaid >= 0 ? ColorTranslator.FromHtml(UserConfigService.Theme.PositiveColor) : ColorTranslator.FromHtml(UserConfigService.Theme.NegativeColor);
            var totalProfitLabel         = $"{MainService.CurrencySymbol}{totalOverall - totalPaid:0.00}";
            var totalNegativeProfitLabel = $"{MainService.CurrencySymbol}{totalNegativeProfits:0.00}";
            var totalPositiveProfitLabel = $"{MainService.CurrencySymbol}{totalPostivieProfits:0.00}";
            var totalOverallLabel        = $"{MainService.CurrencySymbol}{totalOverall:0.00}";
            var totalInvested            = $"{MainService.CurrencySymbol}{totalPaid:0.00}";
            var profitPercentage         = $"{Math.Abs(((1 - totalPaid.SafeDivision(totalOverall))) * 100):0.00}%";

            Invoke((MethodInvoker) delegate
            {
                lblTotalProfit.ForeColor        = totalProfitColor;
                lblProfitPercentage.ForeColor   = totalProfitColor;
                lblTotalProfit.Text             = totalProfitLabel;
                lblTotalNegativeProfit.Text     = totalNegativeProfitLabel;
                lblTotalPositiveProfit.Text     = totalPositiveProfitLabel;
                lblOverallTotal.Text            = totalOverallLabel;
                lblTotalInvested.Text           = totalInvested;
                lblProfitPercentage.Text        = profitPercentage;
                alertsToolStripMenuItem.Enabled = true;
                coinsToolStripMenuItem.Enabled  = true;
            });
        }
Ejemplo n.º 29
0
        /// <remarks>
        /// ALTHOUGH PUBLIC THIS METHOD IS NOT INTENDED TO BE CALLED OUTSIDE OF THIS CLASS
        /// </remarks>
        public void CreateGeneratedMaps()
        {
            IMappingService mappingService = new MappingService();

            #region Generated Type Mappings

            mappingService.CreateMap <AbuseType, AbuseTypeDC>();
            mappingService.CreateMap <AbuseTypeDC, AbuseType>();
            mappingService.CreateMap <AbuseType, AbuseTypeSearchMatchDC>();

            mappingService.CreateMap <ADRoleLookup, ADRoleLookupDC>();
            mappingService.CreateMap <ADRoleLookupDC, ADRoleLookup>();
            mappingService.CreateMap <ADRoleLookup, ADRoleLookupSearchMatchDC>();

            mappingService.CreateMap <Application, ApplicationDC>();
            mappingService.CreateMap <ApplicationDC, Application>();
            mappingService.CreateMap <Application, ApplicationSearchMatchDC>();

            mappingService.CreateMap <ApplicationAttribute, ApplicationAttributeDC>();
            mappingService.CreateMap <ApplicationAttributeDC, ApplicationAttribute>();
            mappingService.CreateMap <ApplicationAttribute, ApplicationAttributeSearchMatchDC>();

            mappingService.CreateMap <ApplicationOrganisationTypeGroup, ApplicationOrganisationTypeGroupDC>();
            mappingService.CreateMap <ApplicationOrganisationTypeGroupDC, ApplicationOrganisationTypeGroup>();
            mappingService.CreateMap <ApplicationOrganisationTypeGroup, ApplicationOrganisationTypeGroupSearchMatchDC>();

            mappingService.CreateMap <Attachment, AttachmentDC>();
            mappingService.CreateMap <AttachmentDC, Attachment>();
            mappingService.CreateMap <Attachment, AttachmentSearchMatchDC>();

            mappingService.CreateMap <AttachmentData, AttachmentDataDC>();
            mappingService.CreateMap <AttachmentDataDC, AttachmentData>();
            mappingService.CreateMap <AttachmentData, AttachmentDataSearchMatchDC>();

            mappingService.CreateMap <Audit, AuditDC>();
            mappingService.CreateMap <AuditDC, Audit>();
            mappingService.CreateMap <Audit, AuditSearchMatchDC>();

            mappingService.CreateMap <Content, ContentDC>();
            mappingService.CreateMap <ContentDC, Content>();
            mappingService.CreateMap <Content, ContentSearchMatchDC>();

            mappingService.CreateMap <ContingencyArrangement, ContingencyArrangementDC>();
            mappingService.CreateMap <ContingencyArrangementDC, ContingencyArrangement>();
            mappingService.CreateMap <ContingencyArrangement, ContingencyArrangementSearchMatchDC>();

            mappingService.CreateMap <ControlMeasure, ControlMeasureDC>();
            mappingService.CreateMap <ControlMeasureDC, ControlMeasure>();
            mappingService.CreateMap <ControlMeasure, ControlMeasureSearchMatchDC>();

            mappingService.CreateMap <Customer, CustomerDC>();
            mappingService.CreateMap <CustomerDC, Customer>();
            mappingService.CreateMap <Customer, CustomerSearchMatchDC>();

            mappingService.CreateMap <CustomerContingencyArrangement, CustomerContingencyArrangementDC>();
            mappingService.CreateMap <CustomerContingencyArrangementDC, CustomerContingencyArrangement>();
            mappingService.CreateMap <CustomerContingencyArrangement, CustomerContingencyArrangementSearchMatchDC>();

            mappingService.CreateMap <CustomerControlMeasure, CustomerControlMeasureDC>();
            mappingService.CreateMap <CustomerControlMeasureDC, CustomerControlMeasure>();
            mappingService.CreateMap <CustomerControlMeasure, CustomerControlMeasureSearchMatchDC>();

            mappingService.CreateMap <EventLeadingToIncident, EventLeadingToIncidentDC>();
            mappingService.CreateMap <EventLeadingToIncidentDC, EventLeadingToIncident>();
            mappingService.CreateMap <EventLeadingToIncident, EventLeadingToIncidentSearchMatchDC>();

            mappingService.CreateMap <Grade, GradeDC>();
            mappingService.CreateMap <GradeDC, Grade>();
            mappingService.CreateMap <Grade, GradeSearchMatchDC>();

            mappingService.CreateMap <Incident, IncidentDC>();
            mappingService.CreateMap <IncidentDC, Incident>();
            mappingService.CreateMap <Incident, IncidentSearchMatchDC>();

            mappingService.CreateMap <IncidentCategory, IncidentCategoryDC>();
            mappingService.CreateMap <IncidentCategoryDC, IncidentCategory>();
            mappingService.CreateMap <IncidentCategory, IncidentCategorySearchMatchDC>();

            mappingService.CreateMap <IncidentDetail, IncidentDetailDC>();
            mappingService.CreateMap <IncidentDetailDC, IncidentDetail>();
            mappingService.CreateMap <IncidentDetail, IncidentDetailSearchMatchDC>();

            mappingService.CreateMap <IncidentInterestedParty, IncidentInterestedPartyDC>();
            mappingService.CreateMap <IncidentInterestedPartyDC, IncidentInterestedParty>();
            mappingService.CreateMap <IncidentInterestedParty, IncidentInterestedPartySearchMatchDC>();

            mappingService.CreateMap <IncidentLink, IncidentLinkDC>();
            mappingService.CreateMap <IncidentLinkDC, IncidentLink>();
            mappingService.CreateMap <IncidentLink, IncidentLinkSearchMatchDC>();

            mappingService.CreateMap <IncidentLocation, IncidentLocationDC>();
            mappingService.CreateMap <IncidentLocationDC, IncidentLocation>();
            mappingService.CreateMap <IncidentLocation, IncidentLocationSearchMatchDC>();

            mappingService.CreateMap <IncidentSystemMarked, IncidentSystemMarkedDC>();
            mappingService.CreateMap <IncidentSystemMarkedDC, IncidentSystemMarked>();
            mappingService.CreateMap <IncidentSystemMarked, IncidentSystemMarkedSearchMatchDC>();

            mappingService.CreateMap <IncidentType, IncidentTypeDC>();
            mappingService.CreateMap <IncidentTypeDC, IncidentType>();
            mappingService.CreateMap <IncidentType, IncidentTypeSearchMatchDC>();

            mappingService.CreateMap <IncidentUpdateEvent, IncidentUpdateEventDC>();
            mappingService.CreateMap <IncidentUpdateEventDC, IncidentUpdateEvent>();
            mappingService.CreateMap <IncidentUpdateEvent, IncidentUpdateEventSearchMatchDC>();

            mappingService.CreateMap <InterestedParty, InterestedPartyDC>();
            mappingService.CreateMap <InterestedPartyDC, InterestedParty>();
            mappingService.CreateMap <InterestedParty, InterestedPartySearchMatchDC>();

            mappingService.CreateMap <IntroductoryInformation, IntroductoryInformationDC>();
            mappingService.CreateMap <IntroductoryInformationDC, IntroductoryInformation>();
            mappingService.CreateMap <IntroductoryInformation, IntroductoryInformationSearchMatchDC>();

            mappingService.CreateMap <JobRole, JobRoleDC>();
            mappingService.CreateMap <JobRoleDC, JobRole>();
            mappingService.CreateMap <JobRole, JobRoleSearchMatchDC>();

            mappingService.CreateMap <LinkedCustomer, LinkedCustomerDC>();
            mappingService.CreateMap <LinkedCustomerDC, LinkedCustomer>();
            mappingService.CreateMap <LinkedCustomer, LinkedCustomerSearchMatchDC>();

            mappingService.CreateMap <Narrative, NarrativeDC>();
            mappingService.CreateMap <NarrativeDC, Narrative>();
            mappingService.CreateMap <Narrative, NarrativeSearchMatchDC>();

            mappingService.CreateMap <Organisation, OrganisationDC>();
            mappingService.CreateMap <OrganisationDC, Organisation>();
            mappingService.CreateMap <Organisation, OrganisationSearchMatchDC>();

            mappingService.CreateMap <OrganisationHierarchy, OrganisationHierarchyDC>();
            mappingService.CreateMap <OrganisationHierarchyDC, OrganisationHierarchy>();
            mappingService.CreateMap <OrganisationHierarchy, OrganisationHierarchySearchMatchDC>();

            mappingService.CreateMap <OrganisationType, OrganisationTypeDC>();
            mappingService.CreateMap <OrganisationTypeDC, OrganisationType>();
            mappingService.CreateMap <OrganisationType, OrganisationTypeSearchMatchDC>();

            mappingService.CreateMap <OrganisationTypeGroup, OrganisationTypeGroupDC>();
            mappingService.CreateMap <OrganisationTypeGroupDC, OrganisationTypeGroup>();
            mappingService.CreateMap <OrganisationTypeGroup, OrganisationTypeGroupSearchMatchDC>();

            mappingService.CreateMap <Referrer, ReferrerDC>();
            mappingService.CreateMap <ReferrerDC, Referrer>();
            mappingService.CreateMap <Referrer, ReferrerSearchMatchDC>();

            mappingService.CreateMap <RelationshipToCustomer, RelationshipToCustomerDC>();
            mappingService.CreateMap <RelationshipToCustomerDC, RelationshipToCustomer>();
            mappingService.CreateMap <RelationshipToCustomer, RelationshipToCustomerSearchMatchDC>();

            mappingService.CreateMap <ReportCategory, ReportCategoryDC>();
            mappingService.CreateMap <ReportCategoryDC, ReportCategory>();
            mappingService.CreateMap <ReportCategory, ReportCategorySearchMatchDC>();

            mappingService.CreateMap <Role, RoleDC>();
            mappingService.CreateMap <RoleDC, Role>();
            mappingService.CreateMap <Role, RoleSearchMatchDC>();

            mappingService.CreateMap <Site, SiteDC>();
            mappingService.CreateMap <SiteDC, Site>();
            mappingService.CreateMap <Site, SiteSearchMatchDC>();

            mappingService.CreateMap <SiteStaff, SiteStaffDC>();
            mappingService.CreateMap <SiteStaffDC, SiteStaff>();
            mappingService.CreateMap <SiteStaff, SiteStaffSearchMatchDC>();

            mappingService.CreateMap <Staff, StaffDC>();
            mappingService.CreateMap <StaffDC, Staff>();
            mappingService.CreateMap <Staff, StaffSearchMatchDC>();

            mappingService.CreateMap <StaffAttributes, StaffAttributesDC>();
            mappingService.CreateMap <StaffAttributesDC, StaffAttributes>();
            mappingService.CreateMap <StaffAttributes, StaffAttributesSearchMatchDC>();

            mappingService.CreateMap <StaffOrganisation, StaffOrganisationDC>();
            mappingService.CreateMap <StaffOrganisationDC, StaffOrganisation>();
            mappingService.CreateMap <StaffOrganisation, StaffOrganisationSearchMatchDC>();

            mappingService.CreateMap <StandardReport, StandardReportDC>();
            mappingService.CreateMap <StandardReportDC, StandardReport>();
            mappingService.CreateMap <StandardReport, StandardReportSearchMatchDC>();

            mappingService.CreateMap <SystemMarked, SystemMarkedDC>();
            mappingService.CreateMap <SystemMarkedDC, SystemMarked>();
            mappingService.CreateMap <SystemMarked, SystemMarkedSearchMatchDC>();

            mappingService.CreateMap <SystemParameter, SystemParameterDC>();
            mappingService.CreateMap <SystemParameterDC, SystemParameter>();
            mappingService.CreateMap <SystemParameter, SystemParameterSearchMatchDC>();

            #endregion Generated Type Mappings
        }
        public ActionResult Booking(AppointmentViewModel appointment)
        {
            appointment.Status = "Pending";

            var startend = appointment.SessionId.Split('-');

            var date = Convert.ToDateTime(appointment.DateStart);

            var datetimeStart = date.ToShortDateString() + " " + startend[0];
            var datetimeEnd   = date.ToShortDateString() + " " + startend[1];

            appointment.DateStart = DateTime.Parse(datetimeStart);
            appointment.DateEnd   = DateTime.Parse(datetimeEnd);

            appointment.SessionId = appointment.DateStart.ToString("ddMMyyyyHHmm") + appointment.DateEnd.ToString("HHmm");

            try
            {
                using (var db = new ddiarydbEntities())
                {
                    Appointment obj = new MappingService().Map <AppointmentViewModel, Appointment>(appointment);
                    obj.DoctorId = int.Parse(new EncryptDecrypt().Decrypt(appointment.Doctor.DoctorId_Encrypt));

                    //db.Appointments.Add(obj);
                    //db.SaveChanges();
                    AppointmentAPIController aController  = new AppointmentAPIController();
                    ReturnObject             returnObject = new ReturnObject();

                    if (appointment.Id != 0)
                    {
                        returnObject = aController.Update_Appointment(obj);
                    }
                    else
                    {
                        returnObject = aController.Insert_Appointment(obj);
                    }

                    try
                    {
                        if (returnObject != null)
                        {
                            Appointment a = (Appointment)returnObject.data1;

                            var doctor = db.Doctor_Master.Where(x => x.Doctor_id == obj.DoctorId).FirstOrDefault();

                            TempData["DoctorName"] = doctor.Doctor_name;

                            string id = new EncryptDecrypt().Encrypt(a.Id.ToString());

                            return(Redirect("AppointmentDetails?id=" + id));
                        }

                        return(Redirect("Booking?id=" + appointment.Doctor.DoctorId_Encrypt));
                    }
                    catch (Exception ex)
                    {
                        ModelState.AddModelError(string.Empty, "Something Wrong.!");
                        return(View(appointment));
                    }
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError(string.Empty, "Something Wrong.!");
                return(View(appointment));
            }
        }
Ejemplo n.º 31
0
        internal static void StartData()
        {
            //add contact "6acb9fb3-9213-49cd-abda-f9785a658d12"
            //var contact = new BLL.Contact();
            //contact.Id = Guid.Parse("6acb9fb3-9213-49cd-abda-f9785a658d12");
            //contact.FirstName = "Гайдель";
            //contact.LastName = "Ирина";
            ////AutoMapper DAL
            //var contactDAL = MappingService.MappingForDALEntity(contactService, contact);
            //contactService.Add(contactDAL);
            //SaveChangesWithException(contactService, "контакта");

            var contact = new BLL.Contact();

            contact.Id        = Guid.Parse("6acb9fb3-9213-49cd-abda-f9785a658d22");
            contact.FirstName = "Гайдель";
            contact.LastName  = "Лев";
            //AutoMapper DAL
            var contactDAL = MappingService.MappingForDALEntity(contactService, contact);

            contactService.Add(contactDAL);
            SaveChangesWithException(contactService, "контакта");

            //add manager "6acb9fb3-9213-49cd-abda-f9785a658d88"
            //80AB7036-5D4A-11E6-9903-0050569977A1
            //var manager = new BLL.Manager();
            //manager.Id = Guid.Parse("80AB7036-5D4A-11E6-9903-0050569977A1");
            //manager.ContactId = contact.Id;
            ////AutoMapper DAL
            //var managerDAL = MappingService.MappingForDALEntity(managerService, manager);
            //managerService.Add(managerDAL);
            //SaveChangesWithException(managerService, "менеджера");
            var manager = new BLL.Manager();

            //manager.Id = Guid.Parse("80AB7036-5D4A-11E6-9903-005056997722");
            manager.Id        = Guid.Parse("80AB7036-5D4A-11E6-9903-0050569977A1");
            manager.ContactId = contact.Id;
            //AutoMapper DAL
            var managerDAL = MappingService.MappingForDALEntity(managerService, manager);

            managerService.Add(managerDAL);
            SaveChangesWithException(managerService, "менеджера");

            //add client 6acb9fb3-9213-49cd-abda-f9785a658d55
            //var client = new BLL.Client();
            //client.Id = Guid.Parse("6acb9fb3-9213-49cd-abda-f9785a658d55");
            //client.ContactId = contact.Id;
            ////AutoMapper DAL
            //var clientDAL = MappingService.MappingForDALEntity(clientService, client);
            //clientService.Add(clientDAL);
            //SaveChangesWithException(clientService, "клиента");

            //var client = new BLL.Client();
            //client.Id = Guid.Parse("6acb9fb3-9213-49cd-abda-f9785a658d22");
            //client.ContactId = contact.Id;
            //client.Name = "Haidzel Iryna Ivanovna";
            ////AutoMapper DAL
            //var clientDAL = MappingService.MappingForDALEntity(clientService, client);
            //clientService.Add(clientDAL);
            //SaveChangesWithException(clientService, "клиента");

            //add product
            //var product = new BLL.Product();
            //product.Id = Guid.Parse("89a5c4a4-6d02-412f-bb58-55a09f8afc7d");
            ////AutoMapper DAL
            //var productDAL = MappingService.MappingForDALEntity(productService, product);
            //productService.Add(productDAL);
            //SaveChangesWithException(productService, "продукта");

            //var product = new BLL.Product();
            //product.Id = Guid.Parse("89a5c4a4-6d02-412f-bb58-55a09f8afc22");
            //product.Name = "boots";
            ////AutoMapper DAL
            //var productDAL = MappingService.MappingForDALEntity(productService, product);
            //productService.Add(productDAL);
            //SaveChangesWithException(productService, "продукта");
        }
        public AddressAM FromExternalAddress(AddressEM source)
        {
            var destination = new AddressAM();

            return(MappingService.Map(source, destination));
        }
        public AddressAM FromDomainAddress(Address source)
        {
            var destination = new AddressAM();

            return(MappingService.Map(source, destination));
        }
Ejemplo n.º 34
0
 public void Configuration(IAppBuilder app)
 {
     MappingService.InitializeMaps();
     ConfigureAuth(app);
     CreateAdminIfNotExist();
 }
Ejemplo n.º 35
0
 public FpmTeacherMapper(MappingService service)
 {
     this.service = service;
 }
Ejemplo n.º 36
0
        public IActionResult Get(AuthorsResourceParameters resourceParameters, [FromHeader(Name = "Accept")] string mediaType)
        {
            if (!MappingService.ValidMappingExistsFor <AuthorDto, Author>
                    (resourceParameters.OrderBy))
            {
                return(BadRequest());
            }

            if (!TypeHelper.TypeHasProperties <AuthorDto>(resourceParameters.Fields))
            {
                return(BadRequest());
            }

            var authors = Repository.GetAuthors(resourceParameters);

            var authorCollection = Mapper.Map <IEnumerable <AuthorDto> >(authors);


            if (mediaType == "application/vnd.netXworks.hateoas+json")
            {
                var paginationMetadata = new
                {
                    totalCount  = authors.TotalCount,
                    pageSize    = authors.PageSize,
                    currentPage = authors.CurrentPage,
                    totalPages  = authors.TotalPages,
                };

                Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));

                var links = CreateAuthorCollectionLinks(resourceParameters, authors.HasNext, authors.HasPrevious);

                var shapedAuthors = authorCollection.ShapeData(resourceParameters.Fields);

                var shapedAuthorLinks = shapedAuthors.Select(author =>
                {
                    var authorAsDictionary = author as IDictionary <string, object>;
                    var authorLinks        = CreateAuthorLinks((Guid)authorAsDictionary["Id"], resourceParameters.Fields);
                    authorAsDictionary.Add("links", authorLinks);
                    return(authorAsDictionary);
                });

                var linkedCollectionResource = new
                {
                    value = shapedAuthorLinks,
                    links = links
                };

                return(Ok(linkedCollectionResource));
            }

            else
            {
                var previousPageLink = authors.HasPrevious ?
                                       CreateAuthorResourceUri(resourceParameters, ResourceUriType.PreviousPage) : null;

                var nextPageLink = authors.HasNext ?
                                   CreateAuthorResourceUri(resourceParameters, ResourceUriType.NextPage) : null;

                var paginationMetadata = new
                {
                    previousPageLink,
                    nextPageLink,
                    totalCount  = authors.TotalCount,
                    pageSize    = authors.PageSize,
                    currentPage = authors.CurrentPage,
                    totalPages  = authors.TotalPages
                };

                Response.Headers.Add("X-Pagination",
                                     JsonConvert.SerializeObject(paginationMetadata));

                return(Ok(authorCollection.ShapeData(resourceParameters.Fields)));
            }
        }
        private NewPartnerCallViewModel PrepareNewCallViewData(CfCacheIndexEntry place)
        {
            var m = new NewPartnerCallViewModel()
            {
                ParnterCallPlaceID = place.ID, ForIndoor = true, ForOutdoor = true
            };

            if (place.Type == CfType.Country)
            {
                ViewBag.PlaceDisallowed = true;
                ViewBag.Place           = place;
            }
            else if (place.Type == CfType.Province)
            {
                var area = geoSvc.GetAreaByID(place.ID);

                ViewBag.PlaceDisallowed = true;
                ViewBag.Place           = place;

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreas(area).Where(a => a.Type != CfType.Province &&
                                                                                   !a.DisallowPartnerCalls).ToList();
            }
            else if (place.Type.ToPlaceCateogry() == PlaceCategory.Area)
            {
                ViewBag.PlaceType = "Area";
                var area = geoSvc.GetAreaByID(place.ID);
                ViewBag.Place = area;

                if (area.DisallowPartnerCalls)
                {
                    ViewBag.PlaceDisallowed = true;
                }
                else
                {
                    var geoJsonUrl = Stgs.MapSvcRelativeUrl + "area/" + place.ID.ToString();

                    var mapModel = new Bing7GeoJsonMapViewModel("climbing-map-" + place.ID, 680, 400, geoJsonUrl);
                    mapModel.ViewOptions = new Bing7MapViewOptionsViewModel(mappingSvc.GetBingViewByID(area.ID));
                    var mapItems = new MappingService().GetAreaEditMapItems(area);
                    ViewBag.MapItemsArea = mapItems.Items[0];
                    mapItems.Items.RemoveAt(0);
                    ViewBag.MapItemsLocations = mapItems.Items;
                    ViewBag.MapModel          = mapModel;
                }

                ViewBag.ChildLocations = geoSvc.GetGeoDeduciblePlaces(place).Where(p => p.Type.IsLocation());

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreas(area).Where(a => a.Type != CfType.Province &&
                                                                                   !a.DisallowPartnerCalls).ToList();
            }
            else if (place.Type.ToPlaceCateogry() == PlaceCategory.IndoorClimbing ||
                     place.Type.ToPlaceCateogry() == PlaceCategory.OutdoorClimbing)
            {
                ViewBag.PlaceType = "Location";
                var location = geoSvc.GetLocationByID(place.ID);
                ViewBag.Place = location;

                if (location.IsIndoorClimbing)
                {
                    m.ForOutdoor = false;
                }
                if (location.IsOutdoorClimbing)
                {
                    m.ForIndoor = false;
                }

                var mapModel = new Bing7MapWithLocationViewModel(location.NameUrlPart, 732, 340, location.Latitude,
                                                                 location.Longitude, location.AvatarRelativeUrl);

                var mapViewSettings = mappingSvc.GetBingViewByID(location.ID);
                if (mapViewSettings == default(PlaceBingMapView))
                {
                    mapViewSettings = PlaceBingMapView.GetDefaultIndoorSettings(location);
                }
                mapModel.ViewOptions    = new Bing7MapViewOptionsViewModel(mapViewSettings);
                ViewBag.LocationMapView = mapModel;

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreasOfPoint(location.Latitude, location.Longitude)
                                           .Where(a => a.Type != CfType.Province && !a.DisallowPartnerCalls).ToList();
            }
            else
            {
                throw new ArgumentException("Place type [" + place.Type.ToString() + "] not supported for partner calls");
            }

            return(m);
        }
Ejemplo n.º 38
0
 public TypeMapper(MappingService mappingService)
 {
     _mappingService = mappingService;
 }
Ejemplo n.º 39
0
        private void CreateQueryableProjection()
        {
            try
            {
                foreach (var customMember in CustomMembers)
                {
                    var memberQueryableExpression =
                        MappingService.GetMemberQueryableExpression(customMember.Key.Member.DeclaringType,
                                                                    customMember.Value.Type);
                    var expression = memberQueryableExpression ?? customMember.Value;
                    _bindingExpressions.Add(customMember.Key.Member.Name,
                                            Expression.Bind(customMember.Key.Member, expression));
                }

                foreach (var customMember in CustomFunctionMembers)
                {
                    if (_bindingExpressions.ContainsKey(customMember.Key.Member.Name))
                    {
                        continue;
                    }

                    var memberQueryableExpression =
                        MappingService.GetMemberQueryableExpression(customMember.Key.Member.DeclaringType,
                                                                    customMember.Value.Type);
                    var expression = memberQueryableExpression ?? customMember.Value;
                    _bindingExpressions.Add(customMember.Key.Member.Name,
                                            Expression.Bind(customMember.Key.Member, expression));
                }

                foreach (var autoMember in AutoMembers)
                {
                    if (_bindingExpressions.ContainsKey(autoMember.Value.Name))
                    {
                        continue;
                    }

                    var source      = autoMember.Key as PropertyInfo;
                    var destination = autoMember.Value as PropertyInfo;

                    var memberQueryableExpression =
                        MappingService.GetMemberQueryableExpression(source.PropertyType,
                                                                    destination.PropertyType);

                    var propertyOrField = Expression.PropertyOrField(SourceParameter, autoMember.Key.Name);

                    Expression expression;
                    if (memberQueryableExpression != null)
                    {
                        var lambdaExpression = memberQueryableExpression as LambdaExpression;
                        var projectionAccessMemberVisitor = new ProjectionAccessMemberVisitor(propertyOrField.Type, propertyOrField);
                        var clearanceExp = projectionAccessMemberVisitor.Visit(lambdaExpression.Body);
                        expression =
                            Expression.Condition(
                                Expression.Equal(propertyOrField, Expression.Constant(null, propertyOrField.Type)),
                                Expression.Constant(null, ((PropertyInfo)autoMember.Value).PropertyType), clearanceExp);
                    }
                    else
                    {
                        expression = propertyOrField;
                    }



                    _bindingExpressions.Add(autoMember.Value.Name,
                                            Expression.Bind(autoMember.Value, expression));
                }

                QueryableExpression =
                    Expression.Lambda <Func <T, TN> >(
                        Expression.MemberInit(Expression.New(typeof(TN)), _bindingExpressions.Values), SourceParameter);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(string.Format("Queryable projection is not supported for such mapping. Exception: {0}", ex));
            }
        }
        private NewPartnerCallViewModel PrepareNewCallViewData(CfCacheIndexEntry place)
        {
            var m = new NewPartnerCallViewModel() { ParnterCallPlaceID = place.ID, ForIndoor = true, ForOutdoor = true };

            if (place.Type == CfType.Country)
            {
                ViewBag.PlaceDisallowed = true;
                ViewBag.Place = place;
            }
            else if (place.Type == CfType.Province)
            {
                var area = geoSvc.GetAreaByID(place.ID);

                ViewBag.PlaceDisallowed = true;
                ViewBag.Place = place;

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreas(area).Where(a => a.Type != CfType.Province
                    && !a.DisallowPartnerCalls).ToList();
            }
            else if (place.Type.ToPlaceCateogry() == PlaceCategory.Area)
            {
                ViewBag.PlaceType = "Area";
                var area = geoSvc.GetAreaByID(place.ID);
                ViewBag.Place = area;

                if (area.DisallowPartnerCalls) { ViewBag.PlaceDisallowed = true; }
                else
                {
                    var geoJsonUrl = Stgs.MapSvcRelativeUrl + "area/" + place.ID.ToString();

                    var mapModel = new Bing7GeoJsonMapViewModel("climbing-map-" + place.ID, 680, 400, geoJsonUrl);
                    mapModel.ViewOptions = new Bing7MapViewOptionsViewModel(mappingSvc.GetBingViewByID(area.ID));
                    var mapItems = new MappingService().GetAreaEditMapItems(area);
                    ViewBag.MapItemsArea = mapItems.Items[0];
                    mapItems.Items.RemoveAt(0);
                    ViewBag.MapItemsLocations = mapItems.Items;
                    ViewBag.MapModel = mapModel;
                }

                ViewBag.ChildLocations = geoSvc.GetGeoDeduciblePlaces(place).Where(p=>p.Type.IsLocation());

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreas(area).Where(a => a.Type != CfType.Province
                    && !a.DisallowPartnerCalls).ToList();
            }
            else if (place.Type.ToPlaceCateogry() == PlaceCategory.IndoorClimbing
                || place.Type.ToPlaceCateogry() == PlaceCategory.OutdoorClimbing)
            {
                ViewBag.PlaceType = "Location";
                var location = geoSvc.GetLocationByID(place.ID);
                ViewBag.Place = location;

                if (location.IsIndoorClimbing) { m.ForOutdoor = false; }
                if (location.IsOutdoorClimbing) { m.ForIndoor = false; }

                var mapModel = new Bing7MapWithLocationViewModel(location.NameUrlPart, 732, 340, location.Latitude,
                    location.Longitude, location.AvatarRelativeUrl);

                var mapViewSettings = mappingSvc.GetBingViewByID(location.ID);
                if (mapViewSettings == default(PlaceBingMapView)) { mapViewSettings = PlaceBingMapView.GetDefaultIndoorSettings(location); }
                mapModel.ViewOptions = new Bing7MapViewOptionsViewModel(mapViewSettings);
                ViewBag.LocationMapView = mapModel;

                ViewBag.InterectingAreas = geoSvc.GetIntersectingAreasOfPoint(location.Latitude, location.Longitude)
                    .Where(a => a.Type != CfType.Province && !a.DisallowPartnerCalls).ToList();
            }
            else
            {
                throw new ArgumentException("Place type [" + place.Type.ToString() + "] not supported for partner calls");
            }

            return m;
        }