/// <summary>
/// Used to change the password of the current user account.
/// </summary>
/// <param name="oldPassword">The current password of the user account.</param>
/// <param name="newPassword">The new password.</param>
public async Task ChangePasswordAsync(string oldPassword, string newPassword)
{
var parameters = new ApiParameters(OperationParameters.UserManagement.ChangePassword,
new { oldPassword, newPassword });
await _httpClient.Get(nameof(UserManagementOperations.ChangePassword), parameters);
}
protected override string Post(ServiceProxyInvokeEventArgs invokeArgs, HttpWebRequest request)
{
string baseAddress = invokeArgs.BaseAddress;
string className = invokeArgs.ClassName;
string methodName = invokeArgs.MethodName;
object[] parameters = invokeArgs.PostParameters;
if (className.Equals("securechannel", StringComparison.InvariantCultureIgnoreCase) && methodName.Equals("invoke", StringComparison.InvariantCultureIgnoreCase))
{
// the target is the SecureChannel.Invoke method but we
// need the actual className and method that is in the parameters
// object
string actualClassName = (string)parameters[0];
string actualMethodName = (string)parameters[1];
string jsonParams = (string)parameters[2];
HttpArgs args = new HttpArgs();
args.ParseJson(jsonParams);
if (TypeRequiresApiKey || MethodRequiresApiKey(actualMethodName))
{
ApiKeyResolver.SetKeyToken(request, ApiParameters.GetStringToHash(actualClassName, actualMethodName, args["jsonParams"]));
}
}
return(base.Post(invokeArgs, request));
}
// GET: api/Report/ThisWeek/{workspaceKey}
public Report GetThisWeek(string workspaceKey)
{
string domain = Properties.Settings.Default.Domain;
string workspaceEndpoint = Properties.Settings.Default.WorkspaceEndpoint;
string reportEndpoint = Properties.Settings.Default.ReportEndpoint;
string apiPassword = Properties.Settings.Default.DefaultApiPassword;
string apiToken = WebUtil.GetHeader("ApiToken", Request.Headers);
string email = WebUtil.GetHeader("Email", Request.Headers);
var paths = new ApiPaths(domain, workspaceEndpoint, reportEndpoint);
var parameters = new ApiParameters()
{
WorkspaceKey = workspaceKey,
Since = DateTime.Today,
Until = DateTime.Today.AddDays(7)
};
var credentials = new ApiCredentials
{
ApiKey = apiToken,
ApiPassword = apiPassword,
Email = email
};
var context = new ApiContext(paths, credentials, parameters);
return(new TogglApiRequest(context).GetReport());
}
public void SecureExecutionRequest_ShouldExecute()
{
EnsureRepository();
IHttpContext context = CreateFakeContext(MethodInfo.GetCurrentMethod().Name);
string input = "monkey";
string jsonParams = ApiParameters.ParametersToJsonParamsArray(new object[] { input }).ToJson();
Incubator testIncubator = new Incubator();
testIncubator.Set <Echo>(new Echo());
SecureExecutionRequest request = new SecureExecutionRequest(context, "Echo", "Send", jsonParams);
request.ServiceProvider = testIncubator;
AesKeyVectorPair kvp = new AesKeyVectorPair();
// ensure the symettric key is set
request.Session.SetSymmetricKey(kvp.Key, kvp.IV);
//
request.Execute();
Expect.IsTrue(request.Result.GetType() == typeof(string)); // should be base64 cipher of json result
string result = request.GetResultAs <string>();
Expect.AreEqual(input, result);
CleanUp();
}
public void ApiKey_ExecutionRequestShouldValidateApiKey()
{
RegisterDb();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
string testName = MethodBase.GetCurrentMethod().Name;
IUserResolver mockUserResolver = Substitute.For <IUserResolver>();
mockUserResolver.GetUser(Arg.Any <IHttpContext>()).Returns("testUser");
LocalApiKeyManager.Default.UserResolver = mockUserResolver;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(testName.RandomLetters(6));
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
ExecutionRequest er = new ExecutionRequest("ApiKeyRequiredEcho", "Send", "json")
{
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.JsonTestRequest()
};
string data = ApiParameters.ParametersToJsonParamsObjectString("some random data");
er.InputString = data;
ValidationResult result = er.Validate();
result.Success.IsFalse();
List <ValidationFailures> failures = new List <ValidationFailures>(result.ValidationFailures);
failures.Contains(ValidationFailures.InvalidApiKeyToken).IsTrue();
}
private string AddQueryStrings(ApiParameters queryStringParameters)
{
if (queryStringParameters?.Parameters == null)
{
return(string.Empty);
}
int count = queryStringParameters.Parameters.Count;
if (count > 0)
{
StringBuilder builder = new StringBuilder(35);
builder.Append("?");
int i = 0;
foreach (KeyValuePair <string, string> parameter in queryStringParameters.Parameters)
{
builder.Append($"{parameter.Key}={HttpUtility.UrlEncode(parameter.Value)}");
AppendAmpersandConditonallyBetweenParameters(builder, i, count);
i++;
}
return(builder.ToString());
}
return(string.Empty);
}
public void ApiKey_ExecutionRequestValidationShouldSucceedIfGoodToken()
{
Prepare();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
string methodName = MethodBase.GetCurrentMethod().Name;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(methodName);
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
string className = "ApiKeyRequiredEcho";
string method = "Send";
string data = ApiParameters.ParametersToJsonParamsArray("some random data").ToJson();
ExecutionRequest er = new ExecutionRequest(className, method, "json")
{
JsonParams = data,
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.FormUrlEncodedTestRequest()
};
er.ApiKeyResolver.SetKeyToken(er.Request.Headers, ApiParameters.GetStringToHash(className, method, data));
ValidationResult result = er.Validate();
Expect.IsTrue(result.Success);
}
public void ApiKey_ExecutionRequestValidationShouldFailIfBadToken()
{
RegisterDb();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
IUserResolver mockUserResolver = Substitute.For <IUserResolver>();
mockUserResolver.GetUser(Arg.Any <IHttpContext>()).Returns("testUser");
LocalApiKeyManager.Default.UserResolver = mockUserResolver;
string methodName = MethodBase.GetCurrentMethod().Name;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(methodName.RandomLetters(4));
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
ExecutionRequest er = new ExecutionRequest("ApiKeyRequiredEcho", "Send", "json")
{
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.JsonTestRequest()
};
string data = ApiParameters.ParametersToJsonParamsObjectString("some random data");
er.InputString = data;
ApiKeyResolver resolver = new ApiKeyResolver(keyProvider, nameProvider);
resolver.SetKeyToken(er.Request.Headers, data);
er.Request.Headers[Headers.KeyToken] = "bad token value";
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success, "Validation should have failed");
List <ValidationFailures> failures = new List <ValidationFailures>(result.ValidationFailures);
Expect.IsTrue(failures.Contains(ValidationFailures.InvalidApiKeyToken), "ValidationFailure should have been InvalidApiKeyToken");
}
public async Task <SpotibroModels.PlaylistContents> GetPlaylistContentsAsync(PartyGoer user, string playlistId)
{
var parameters = new ApiParameters
{
Parameters = new Dictionary <string, string>
{
{ "fields", "items(track(id,name,album(images(url)),artists(name,id),explicit(),duration_ms()))" },
{ "market", user.GetMarket() }
},
Keys = new Dictionary <string, string> {
{ "{playlist_id}", playlistId },
}
};
var response = await _spotifyHttpClient.SendHttpRequestAsync(user, _apiEndpoints[ApiEndpointType.GetPlaylistItems], parameters);
response.EnsureSuccessStatusCode();
var playlistItems = await response.Content.ReadFromJsonAsync <PlaylistItems>();
playlistItems.Items.RemoveAll(p => p.Track == null);
return(new SpotibroModels.PlaylistContents()
{
Tracks = playlistItems.Items.Select(p => _mapper.Convert(p.Track)).ToList()
});
}
public async Task <T> Get <T>(string action, ApiParameters parameters)
{
var apiParams = ApiUrl.Create(_apiSettings, action, parameters);
var response = await _httpClient.GetAsync(apiParams);
return(await HandleResponse <T>(response));
}
public async Task Get(string action, ApiParameters parameters = null)
{
var apiParams = ApiUrl.Create(_apiSettings, action, parameters);
var response = await _httpClient.GetAsync(apiParams);
await HandleResponse(response);
}
public static SecureExecutionRequest Create <T>(IHttpContext context, string methodName, Incubator serviceProvider, params object[] parameters)
{
string jsonParams = ApiParameters.ParametersToJsonParamsArray(parameters).ToJson();
SecureExecutionRequest request = new SecureExecutionRequest(context, typeof(T).Name, methodName, jsonParams);
request.ServiceProvider = serviceProvider;
return(request);
}
public static ApiParameters convertToApiParameters(Record obj)
{
ApiParameters param = new ApiParameters();
param.Id = obj.Id.ToString();
/*record to apiparameter id sini alacaksın id ye yazacaksın*/
return(param);
}
public void Validation_ShouldBeAbleToCreateToken()
{
Prepare();
IHttpContext context = CreateFakeContext(MethodBase.GetCurrentMethod().Name);
SecureSession session = SecureSession.Get(context);
string postString = ApiParameters.ParametersToJsonParamsObjectString("random information");
EncryptedValidationToken token = ApiEncryptionValidation.CreateEncryptedValidationToken(postString, session);
}
private async Task <Domain.Contracts.SpotifyApi.Models.ArtistInformation> GetBasicArtistInformationAsync(PartyGoer partyGoer, string artistId)
{
var parameters = new ApiParameters {
Keys = new Dictionary <string, string> {
{ "{id}", artistId }
}
};
var artistResponse = await SendHttpRequestAsync(partyGoer, _apiEndpoints[ApiEndpointType.ArtistInformation], parameters);
return(await artistResponse.Content.ReadFromJsonAsync <Domain.Contracts.SpotifyApi.Models.ArtistInformation>());
}
public static PaginationViewModel <T> Build(IEnumerable <T> items, ApiParameters apiParameters, int totalCount)
{
var paginationViewModel = new PaginationViewModel <T>
{
_items = items.ToList()
};
paginationViewModel.SetPaginationState(totalCount, apiParameters);
return(paginationViewModel);
}
public AsyncExecutionRequest CreateRequest(Type type, string methodName, params object[] arguments)
{
return(new AsyncExecutionRequest
{
RespondToHostName = HostPrefix.HostName,
RespondToPort = HostPrefix.Port,
Ssl = HostPrefix.Ssl,
ClassName = type.Name,
MethodName = methodName,
JsonParams = ApiParameters.ParametersToJsonParamsArray(arguments).ToJson()
});
}
private async Task <TopTracks> GetTopTracksAsync(PartyGoer partyGoer, string artistId)
{
ApiParameters parameters = new ApiParameters {
Keys = new Dictionary <string, string> {
{ "{id}", artistId }
}, Parameters = new Dictionary <string, string> {
{ "market", partyGoer.GetMarket() }
}
};
var artistTopTracksResponse = await SendHttpRequestAsync(partyGoer, _apiEndpoints[ApiEndpointType.ArtistTopTracks], parameters);
return(await artistTopTracksResponse.Content.ReadFromJsonAsync <TopTracks>());
}
public bool IsValidRequest(ExecutionRequest request)
{
Args.ThrowIfNull(request, "request");
string stringToHash = ApiParameters.GetStringToHash(request);
string token = request.Context.Request.Headers[CustomHeaders.KeyToken];
bool result = false;
if (!string.IsNullOrEmpty(token))
{
result = IsValidKeyToken(stringToHash, token);
}
return(result);
}
public void SetPaginationState(int totalCount, ApiParameters apiParameters)
{
Pagination = new PaginationStateViewModel
{
Count = totalCount
};
if (apiParameters != null)
{
Pagination.Page = apiParameters.Page;
Pagination.Limit = apiParameters.Limit;
}
}
public static string Create(ApiSettings settings, string action, ApiParameters parameters)
{
var parametersQuery = parameters.ToQuery();
var query = $"?lang=en&account={settings.Account}&username={settings.Username}" +
$"&password={settings.Password}&apikey={settings.ApiKey}&outputformat=json&action={action}";
if (!string.IsNullOrEmpty(parametersQuery))
{
query += $"&{parametersQuery}";
}
return(query);
}
public List <DeliveryPoint> GetDeliveryPoints(ApiParameters pars, RequestSettings rs = null)
{
var result = new List <DeliveryPoint>();
for (int i = 0; i < 3; i++)
{
result.Add(new DeliveryPoint
{
Id = "id" + i,
Lat = 1,
Lng = 1
});
}
return(result);
}
public IActionResult RecordList(ApiParameters param)
{
if (param.sortOrderString == "0")
{
param.sortOrderString = "asc";
}
else
{
param.sortOrderString = "desc";
}
var model = record.getRecords("fromIndex=" + param.fromIndex + "&toIndex=" + param.toIndex + "&sortOrderString=" + param.sortOrderString);
TempData["recordList"] = model;
return(View());
}
public async Task <Domain.Errors.ServiceResult <UpdateSongError> > UpdateSongForPartyGoerAsync(PartyGoer partyGoer, List <string> songUris, int currentSongProgressInMs)
{
string perferredDeviceId = partyGoer.GetPerferredDeviceId();
ApiParameters parameters = null;
if (!string.IsNullOrWhiteSpace(perferredDeviceId))
{
parameters = new ApiParameters
{
Parameters = new Dictionary <string, string>
{
{ "device_id", perferredDeviceId }
}
};
}
HttpResponseMessage response = null;
if (parameters != null)
{
response = await SendHttpRequestAsync(partyGoer, _apiEndpoints[ApiEndpointType.PlaySong], parameters,
new StartUserPlaybackSong { uris = songUris.Select(song => song.Contains("spotify:track:") ? song : $"spotify:track:{song}".Split('+').First()).ToList(), position_ms = currentSongProgressInMs });
}
else
{
response = await SendHttpRequestAsync(partyGoer, _apiEndpoints[ApiEndpointType.PlaySong],
new StartUserPlaybackSong { uris = songUris.Select(song => song.Contains("spotify:track:") ? song : $"spotify:track:{song}".Split('+').First()).ToList(), position_ms = currentSongProgressInMs });
}
Domain.Errors.ServiceResult <UpdateSongError> error = new Domain.Errors.ServiceResult <UpdateSongError>();
if (response.IsSuccessStatusCode)
{
return(error);
}
else
{
await _logService.LogExceptionAsync(new Exception($"Unable to update song for {partyGoer.GetId()}"), await response.Content.ReadAsStringAsync());
// TODO: Check status codes and add specific messaging for status codes based on Spotifys API
error.AddError(new UpdateSongError($"Unable to update song for {partyGoer.GetId()}"));
return(error);
}
}
public async Task <ServiceResult <PaginationViewModel <string> > > GetDictionaryKeys(ApiParameters apiParameters)
{
if (apiParameters == null)
{
apiParameters = new ApiParameters();
}
var serviceResult = new ServiceResult <PaginationViewModel <string> >();
serviceResult.Data = (await UnitOfWork
.RepositoryAsync <Dictionary>()
.Query()
.OrderBy(q => q.OrderBy(dictionary => dictionary.Key))
.SelectPageAsync(apiParameters.Page, apiParameters.Limit, true))
.Mutate(q => q.Key);
return(serviceResult);
}
public void GetDeliveryPointsTests()
{
var pointForMapParams = new ApiParameters
{
MinLat = 55.30077916694387m,
MaxLat = 56.200586833056136m,
MinLng = 36.974153699712836m,
MaxLng = 38.26083830028717m
};
var deliveryPoints = _client.GetDeliveryPoints(pointForMapParams);
var first = deliveryPoints.FirstOrDefault();
Assert.True(deliveryPoints != null);
Assert.True(deliveryPoints.Count > 0);
Assert.True(first != null && !string.IsNullOrWhiteSpace(first.Id) &&
first.Lat > 0 && first.Lng > 0);
}
public bool IsValidRequest(ExecutionRequest request)
{
Args.ThrowIfNull(request, "request");
string className = request.ClassName;
string methodName = request.MethodName;
string stringToHash = ApiParameters.GetStringToHash(className, methodName, request.JsonParams);
string token = request.Context.Request.Headers[Headers.KeyToken];
bool result = false;
if (!string.IsNullOrEmpty(token))
{
result = IsValidKeyToken(stringToHash, token);
}
return(result);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
ApiParameters.CarregarParametros();
services.AddControllers();
services.AddJsonSetup();
services.RegisterServices();
services.AddAutoMapperSetup();
services.AddSwaggerSetup();
services.AddDataBaseSetup();
services.AddMvc().AddFluentValidation((mvcConfiguration => mvcConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>()));
services.AddRouting(options =>
{
options.LowercaseUrls = true;
options.LowercaseQueryStrings = true;
});
}
} /*-*/
#endregion
#region convert string to ApiParameters
public static ApiParameters convertToApiParameters(string obj)
{
var parameters = obj.Split("&");
Dictionary <string, string> dicti = new Dictionary <string, string>();
foreach (var item in parameters)
{
var param = item.Split("=");
dicti.Add(param[0], param[1]);
}
ApiParameters api = new ApiParameters();
api.fromIndex = dicti["fromIndex"];
api.toIndex = dicti["toIndex"];
//api.sortColumnString = dicti["sortColumnString"];
api.sortOrderString = dicti["sortOrderString"];
//api.lastModifiedTime =Convert.ToDateTime(dicti["lastModifiedTime"]);
return(api);
}
public async Task <List <SpotibroModels.PlaylistSummary> > GetUsersPlaylistsAsync(PartyGoer user, int limit = 10, int offset = 0)
{
try
{
var parameters = new ApiParameters
{
Parameters = new Dictionary <string, string>
{
{ "limit", limit.ToString() },
{ "offset", offset.ToString() }
}
};
var response = await _spotifyHttpClient.SendHttpRequestAsync(user, _apiEndpoints[ApiEndpointType.GetUserPlaylists], parameters, null);
response.EnsureSuccessStatusCode();
PagedObject <UsersPlaylist> spotifyPlaylists = await response.Content.ReadFromJsonAsync <PagedObject <UsersPlaylist> >();
List <SpotibroModels.PlaylistSummary> playlistSummaries = new List <SpotibroModels.PlaylistSummary>();
foreach (var playlist in spotifyPlaylists.Items)
{
playlistSummaries.Add(new SpotibroModels.PlaylistSummary {
Name = playlist.Name, PlaylistCoverArtUrl = playlist.Images.FirstOrDefault().Url, Id = playlist.Id
});
}
return(playlistSummaries);
}
catch (Exception ex)
{
await _logService.LogExceptionAsync(ex, "Error occurred in GetUsersPlaylistsAsync");
return(null);
}
}
