public ArtistModule()
: base("/artist")
{
var mappingService = new MappingService(new LastFmLoader(), "artists");
Get["/"] = _ => MapUsing(mappingService);
Post["/"] = _ => MapUsing(mappingService);
}
public AlbumModule()
: base("/album")
{
var mappingService = new MappingService(new LastFmLoader(), "albums");
Get["/"] = _ => MapUsing(mappingService);
Post["/"] = _ => MapUsing(mappingService);
}
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>()));
}
private Response MapUsing(MappingService mappingService)
{
var result = mappingService.Map(Mapping.From(this.Bind<SerializableMapping>()));
var viewmodel = new SerializableMapping();
return Response.AsJson(result.To(viewmodel));
}
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
});
}
/// <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));
}
/// <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));
}
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);
}
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);
}
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));
}
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));
}
/// <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));
}
/// <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);
}
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);
}
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);
}
}
/// <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));
}
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);
}
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));
}
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);
}
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;
}
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;
});
}
/// <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));
}
}
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));
}
public void Configuration(IAppBuilder app)
{
MappingService.InitializeMaps();
ConfigureAuth(app);
CreateAdminIfNotExist();
}
public FpmTeacherMapper(MappingService service)
{
this.service = service;
}
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);
}
public TypeMapper(MappingService mappingService)
{
_mappingService = mappingService;
}
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;
}
