private async Task <int> GetLocationId(string province, string city)
{
var reqMasterlist = new HttpRequestMessage(HttpMethod.Get, "/api/masterlists");
await AccessTokenProvider.AuthenticateRequestAsAppAsync(reqMasterlist);
var resMasterlist = await Client.SendAsync(reqMasterlist);
string jsonString = await resMasterlist.Content.ReadAsStringAsync();
var locations = JsonConvert.DeserializeObject <OkResponse <MasterResource> >(jsonString).payload.Locations;
return(locations[province][city]);
}
private async Task <int> GetDisciplineIdFromName(string disciplineName)
{
var reqMasterlist = new HttpRequestMessage(HttpMethod.Get, "/api/masterlists");
await AccessTokenProvider.AuthenticateRequestAsAppAsync(reqMasterlist);
var resMasterlist = await Client.SendAsync(reqMasterlist);
string jsonString = await resMasterlist.Content.ReadAsStringAsync();
var disc = JsonConvert.DeserializeObject <OkResponse <MasterResource> >(jsonString).payload.Disciplines;
return(disc[disciplineName].DisciplineID);
}
public async Task GetOneUser_ExpectOneDiscipline(string url)
{
var req = new HttpRequestMessage(HttpMethod.Get, $"{url}/{userId}");
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
string jsonString = await res.Content.ReadAsStringAsync();
var jsonObject = JsonConvert.DeserializeObject <OkResponse <UserProfile> >(jsonString);
Assert.Single(jsonObject.payload.Disciplines);
}
static void Main(string[] args)
{
var stopwatch = new Stopwatch();
var logFile = "log.txt";
stopwatch.Start();
var fcsClientConfig = BuildConfig();
var accessTokenProvider = new AccessTokenProvider(fcsClientConfig);
var httpClient = new FcsHttpClientFactory(accessTokenProvider).Create();
var syndicationFeedService = new SyndicationFeedService(httpClient);
var fcsSyndicationFeedParserService = new FcsSyndicationFeedParserService(new XmlSerializationService());
var contractMappingService = new ContractMappingService();
var fcsFeedService = new FcsFeedService(syndicationFeedService, fcsSyndicationFeedParserService, contractMappingService);
var existingSyndicationItemIds = new List <Guid>();
using (var fcsContext = new FcsContext(fcsClientConfig.ConnectionString))
{
existingSyndicationItemIds = new FcsContractsPersistenceService(fcsContext).GetExistingSyndicationItemIds(CancellationToken.None).Result.ToList();
}
var fcsContracts = fcsFeedService.GetNewContractorsFromFeedAsync(fcsClientConfig.FeedUri + "/api/contracts/notifications/approval-onwards", existingSyndicationItemIds, CancellationToken.None).Result.ToList();
File.AppendAllText(logFile, stopwatch.ElapsedMilliseconds + " ms - got FCS Contracts" + fcsContracts.Count);
//var fcsContracts = fcsFeedService.LoadContractsFromFeedToEndAsync(fcsClientConfig.FeedUri + "/api/contracts/notifications/approval-onwards", CancellationToken.None).Result.ToList();
File.AppendAllText(logFile, stopwatch.ElapsedMilliseconds + " ms - map to DC Contracts - " + fcsContracts.Count);
// var dcContracts = BuildMasterContracts(300);
using (var fcsContext = new FcsContext(fcsClientConfig.ConnectionString))
{
fcsContext.Configuration.AutoDetectChangesEnabled = false;
var fcsContractsPersistenceService = new FcsContractsPersistenceService(fcsContext);
fcsContractsPersistenceService.PersistContracts(fcsContracts, CancellationToken.None).Wait();
}
File.AppendAllText(logFile, stopwatch.ElapsedMilliseconds + " ms - Persisted DC Contracts - " + fcsContracts.Count);
}
public async Task GetDisciplines_AfterCreate(string url)
{
var added = Data_POST_Pass().Select(p => p.GetValue(1)).ToHashSet();
var req = new HttpRequestMessage(HttpMethod.Get, url);
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
string jsonString = await res.Content.ReadAsStringAsync();
var jsonObject = JsonConvert.DeserializeObject <OkResponse <MasterResource> >(jsonString);
Assert.True(added.IsProperSubsetOf(jsonObject.payload.Disciplines.Keys));
}
private async Task <HttpResponseMessage> GetResponseMessage_Location_POST(string url, string province, string city)
{
var location = JsonConvert.SerializeObject(GetLocationResource(province, city));
var req = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(
location,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
return(await Client.SendAsync(req));
}
private async Task <HttpResponseMessage> GetResponseMessage_Skill_POST(string url, int disciplineId, string skillName)
{
var discSkill = JsonConvert.SerializeObject(GetDisciplineSkillResource(disciplineId, skillName));
var req = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(
discSkill,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
return(await Client.SendAsync(req));
}
public async Task GetOneProject_AfterUpdate(string url, string projectNumber, string title)
{
var req = new HttpRequestMessage(HttpMethod.Get, $"{url}/{projectNumber}");
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
string jsonString = await res.Content.ReadAsStringAsync();
var jsonObject = JsonConvert.DeserializeObject <OkResponse <ProjectProfile> >(jsonString);
Assert.Equal(title, jsonObject.payload.ProjectSummary.Title);
Assert.Single(jsonObject.payload.Openings);
}
public AccessTokenProviderTests()
{
Func <AccessTokenRefreshResponse> responseProvider =
() => new AccessTokenRefreshResponse
{
AccessToken = Guid.NewGuid().ToString(),
ExpiresIn = _accessTokenExpiresInSeconds,
RefreshToken = Guid.NewGuid().ToString(),
TokenType = "test-token-type"
};
_messageHandler = new MockMessageHandler(responseProvider);
_sut = new AccessTokenProvider(
new TransactClientConfiguration(),
new HttpClient(_messageHandler));
}
public async void GetAccessTokenAsync()
{
Assert.That(_clientId, Is.Not.Null.Or.Empty);
Assert.That(_clientSecret, Is.Not.Null.Or.Empty);
Assert.That(_authorizationResult, Is.Not.Null);
var provider = new AccessTokenProvider(_clientId, _clientSecret);
var handle = await provider.ProvideAsync(_authorizationResult.AuthorizationCode, _authorizationResult.CodeVerifier, _authorizationResult.RedirectUri);
if (!handle.IsFailed)
{
_accessTokenResult = handle.Result;
}
Debug.Log($"Access Token: {_accessTokenResult.AccessToken}");
}
/// <summary>
/// Factory method for creating new <see cref="IAccessTokenProvider"/> instances. <paramref name="httpClient"/> will not be diposed.
/// </summary>
/// <returns>A new <see cref="IAccessTokenProvider"/></returns>
public static IAccessTokenProvider Create(
ITokenSigner tokenSigner,
HttpClient httpClient,
Uri authEndpoint,
TimeSpan tokenRefreshGracePeriod
)
{
IAuthServiceClient authServiceClient = new AuthServiceClient(
httpClient,
authEndpoint
);
INonCachingAccessTokenProvider accessTokenProvider =
new AccessTokenProvider(tokenSigner, authServiceClient);
return(new CachedAccessTokenProvider(accessTokenProvider, authEndpoint, tokenRefreshGracePeriod));
}
public async Task UpdateOneUser_Second(string url)
{
var userProfile = JsonConvert.SerializeObject(GetUserProfile(getTwo: false));
var req = new HttpRequestMessage(HttpMethod.Put, $"{url}/{userId}")
{
Content = new StringContent(
userProfile,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
}
public async Task CreateOneProject(string url, string projectNumber, string title, string discipline, HashSet <string> skills)
{
var projectProfile = JsonConvert.SerializeObject(GetProjectProfile(managerId, projectNumber, title, discipline, skills));
var req = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(
projectProfile,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.Created, res.StatusCode);
}
public void CreateNewTokenAndReturnForUser()
{
var tokenRepository = new Mock <IRepository <Token> >();
var userRepository = new LocalRepository <InsideUser>();
var provider = new AccessTokenProvider(tokenRepository.Object, userRepository);
var userId = "NewGuidString";
userRepository.Add(new InsideUser()
{
Id = userId
});
var result = provider.GetToken(userId);
tokenRepository.Verify(tr => tr.Add(It.IsAny <Token>()), Times.Once);
Assert.AreEqual(DateTime.Today.AddDays(30).Date, result.ExpirationDate.Date);
Assert.AreEqual("NewGuidString", result.UserId);
}
public void ValidateUrlGenerator()
{
var tokenRepository = new Mock <IRepository <Token> >();
var userRepository = new LocalRepository <InsideUser>();
var provider = new AccessTokenProvider(tokenRepository.Object, userRepository);
var userId = "NewGuidString";
userRepository.Add(new InsideUser()
{
Id = userId
});
var urlResult = provider.GenerateAccessUrl(userId, "www.return.url/Action");
tokenRepository.Verify(tr => tr.Add(It.IsAny <Token>()), Times.Once);
tokenRepository.Verify(tr => tr.SaveChanges(), Times.Once);
Assert.IsTrue(urlResult.Contains("&returnUrl=www.return.url%2fAction"));
}
public async Task UpdateOneProject(string url, string projectNumber, string title, string discipline, HashSet <string> skills)
{
// var discipline = "Automation";
// var skills = new HashSet<string> { "Automated teller machines", "Digital labor" };
var projectProfile = JsonConvert.SerializeObject(GetProjectProfile(managerId, projectNumber, title, discipline, skills));
var req = new HttpRequestMessage(HttpMethod.Put, $"{url}/{projectNumber}")
{
Content = new StringContent(
projectProfile,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
}
public APITestFixture()
{
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json");
IConfiguration configuration = builder.Build();
ApplicationSettings = configuration.Get <ApplicationSettings>(c => c.BindNonPublicProperties = true);
ApplicationSettings.ValidateAttributes();
Client = new HttpClient
{
BaseAddress = new Uri(ApplicationSettings.AuthServiceAPISettings.BaseUrl),
};
Client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", ApplicationSettings.AuthServiceAPISettings.OcpApimSubscriptionKey);
AccessTokenProvider = new AccessTokenProvider(configuration.GetSection(nameof(AccessTokenSettings)).Get <AccessTokenSettings>());
}
public void AccessTokenProvider_GetAccessToken_ReturnsTokenWithExpirationDataSet()
{
var expirationData = new DateTime(2018, 04, 14);
var header = new JwtHeader();
var headerProviderMock = new Mock <IHeaderProvider>();
headerProviderMock.Setup(x => x.GetHeader()).Returns(header);
var payload = new JwtPayload();
var payloadProviderMock = new Mock <IPayloadProvider>();
payloadProviderMock.Setup(x => x.GetPayload(It.IsAny <DateTime>(), It.IsAny <Dictionary <string, object> >())).Returns(payload);
var tokenProvider = new AccessTokenProvider(headerProviderMock.Object, payloadProviderMock.Object);
var token = tokenProvider.GetAccessToken(expirationData, new Dictionary <string, object>());
Assert.Equal(expirationData, token.ExpirationDate);
}
public IActionResult Login([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "auth/login")] AuthLoginRequestContract contract)
{
if (string.IsNullOrEmpty(contract.BadgeCode) || string.IsNullOrEmpty(contract.AgentId))
{
return(new BadRequestResult());
}
var id = _authService.Login(contract.AgentId, contract.BadgeCode);
if (id.HasValue)
{
var jwtResult = AccessTokenProvider.GenerateToken(id.ToString());
return(new OkObjectResult(jwtResult));
}
return(new BadRequestObjectResult(new BadRequestResponseContract()
{
Message = "Invalid Username or password."
}));
}
public ActionResult SendSms()
{
var jsonCoverter = new JsonUtcConverter();
var tokenRepository = new Repository <Token>(db => context.Token, context);
var userRepository = new Repository <InsideUser>(db => context.InsideUser, context);
var accessTokenProvider = new AccessTokenProvider(tokenRepository, userRepository);
var url = accessTokenProvider.GenerateAccessUrl(User.Identity.GetUserId(), "/report/" + 10 + "/contact/" + 111818);
var shortUrl = GetShortURL(url);
string AccountSid = "ACf527710731ad6e3852be97b937c418b5";
string AuthToken = "51653777a7b97d349e0da8cb966359a1";
var twilio = new TwilioRestClient(AccountSid, AuthToken);
var message = twilio.SendMessage("+46769438884", "0722524969", "Du har fått ett nytt telefonsamtal från 0722524969: " + shortUrl);
return(Content(jsonCoverter.Serilize(message), "application/json"));
}
public async Task SearchUsers(string url)
{
var searchWord = "ge";
var reqSearch = JsonConvert.SerializeObject(GetRequestSearch(searchWord));
var req = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(
reqSearch,
Encoding.UTF8,
"application/json"
)
};
await AccessTokenProvider.AuthenticateRequestAsAppAsync(req);
var res = await Client.SendAsync(req);
Assert.Equal(HttpStatusCode.OK, res.StatusCode);
string jsonString = await res.Content.ReadAsStringAsync();
var jsonObject = JsonConvert.DeserializeObject <OkResponse <IEnumerable <UserSummary> > >(jsonString);
var userNames = jsonObject.payload.Select(us => $"{us.FirstName} {us.LastName}").ToList();
Assert.True(userNames.All(name => name.ToLower().Trim().Contains(searchWord)));
}
public RestClient(string instanceUrl, string accessToken, AccessTokenProvider accessTokenProvider)
{
_instanceUrl = instanceUrl;
_accessToken = accessToken;
_accessTokenProvider = accessTokenProvider;
}
public void Login(AccessTokenProvider provider) => Login(provider.GetAccessToken());
public RestClient(string instanceUrl, string accessToken, AccessTokenProvider accessTokenProvider)
{
_instanceUrl = instanceUrl;
_accessToken = accessToken;
_accessTokenProvider = accessTokenProvider;
}
public static IConfigius Connect(string appId, string appSecret, string environment, string configiusBaseUrl)
{
IAccessTokenProvider accessTokenProvider = new AccessTokenProvider(configiusBaseUrl, appId, appSecret);
return(new Configius(configiusBaseUrl, accessTokenProvider, appId, environment));
}
protected IntegrationTestBase(AppFixture app)
{
Client = app.Client;
Settings = app.Settings;
AccessTokenProvider = new AccessTokenProvider(app.Settings);
}
protected override async Task OnInitializedAsync()
{
try
{
string baseUrl = NavigationManager.BaseUri;
_hubUrl = baseUrl.TrimEnd('/') + "/chatHub";
hubConnection = new HubConnectionBuilder()
.WithUrl(_hubUrl, options =>
{
options.AccessTokenProvider = async() =>
{
var accessTokenResult = await AccessTokenProvider.GetAuthenticationStateAsync();
return(await storage.GetTokenAsync());
};
})
.Build();
hubConnection.On <MessageViewModel>("newMessage", async(message) =>
{
messages.Insert(0, message);
StateHasChanged();
});
hubConnection.On <string>("onError", async(message) =>
{
MessageViewModel msg = new MessageViewModel();
msg.Content = message;
messages.Insert(0, msg);
StateHasChanged();
});
hubConnection.On <UserViewModel>("joinedRoom", async(message) =>
{
inputModel.CurrentRoom = message.CurrentRoom;
messages.Clear();
IList <MessageViewModel> mess = await hubConnection.InvokeAsync <IList <MessageViewModel> >("GetMessageHistory", inputModel.Room);
foreach (var m in mess)
{
messages.Insert(0, m);
}
StateHasChanged();
});
hubConnection.On <UserViewModel>("removeUser", async(message) =>
{
users = await hubConnection.InvokeAsync <IList <UserViewModel> >("GetUsers", message.CurrentRoom);
StateHasChanged();
});
hubConnection.On <UserViewModel>("addUser", async(message) =>
{
users = await hubConnection.InvokeAsync <IList <UserViewModel> >("GetUsers", message.CurrentRoom);
StateHasChanged();
});
hubConnection.On <RoomViewModel>("removeChatRoom", async(message) =>
{
rooms = await hubConnection.InvokeAsync <IList <RoomViewModel> >("GetRooms");
StateHasChanged();
});
hubConnection.On <RoomViewModel>("addChatRoom", async(message) =>
{
rooms = await hubConnection.InvokeAsync <IList <RoomViewModel> >("GetRooms");
StateHasChanged();
});
hubConnection.On <string>("onRoomDeleted", async(message) =>
{
inputModel.Room = "Lobby";
MessageViewModel msg = new MessageViewModel();
msg.Content = $"Room was deleted, you are now moved back to {inputModel.Room}";
messages.Insert(0, msg);
await JoinRoom();
StateHasChanged();
});
await hubConnection.StartAsync();
username = await hubConnection.InvokeAsync <string>("WhoAmI");
inputModel.Room = "Lobby";
inputModel.Recipent = "Room";
rooms = await hubConnection.InvokeAsync <IList <RoomViewModel> >("GetRooms");
await JoinRoom();
}
catch (Exception ex)
{
MessageViewModel msg = new MessageViewModel();
msg.Content = ex.Message;
messages.Insert(0, msg);
}
finally
{
// this.StateHasChanged();
}
}
public void CanCreate()
{
var tokenRepository = new Mock <IRepository <Token> >();
var userRepository = new Mock <IRepository <InsideUser> >();
var provider = new AccessTokenProvider(tokenRepository.Object, userRepository.Object);
}
