/// <summary>
/// Validate tasks. Checks that there are no missing parameters in the tasks.
/// </summary>
/// <param name="apiSession">api session</param>
/// <param name="projectPath">project path like /path/to/project.morph </param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <ValidateTasksResult> ValidateTasksAsync(ApiSession apiSession, string projectPath, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
if (string.IsNullOrWhiteSpace(projectPath))
{
throw new ArgumentException(nameof(projectPath));
}
var spaceName = apiSession.SpaceName;
var url = "commands/validatetasks";
var request = new ValidateTasksRequestDto
{
SpaceName = spaceName,
ProjectPath = projectPath
};
using (var response = await GetHttpClient().SendAsync(BuildHttpRequestMessage(HttpMethod.Post, url, JsonSerializationHelper.SerializeAsStringContent(request), apiSession), cancellationToken))
{
var dto = await HandleResponse <ValidateTasksResponseDto>(response);
var entity = ValidateTasksResponseMapper.MapFromDto(dto);
return(entity);
}
}
public Task <ApiResult <NoContentResult> > WebFilesDeleteFileAsync(ApiSession apiSession, string serverFilePath, CancellationToken cancellationToken)
{
var spaceName = apiSession.SpaceName;
var url = UrlHelper.JoinUrl("space", spaceName, "files", serverFilePath);
return(apiClient.DeleteAsync <NoContentResult>(url, null, apiSession.ToHeadersCollection(), cancellationToken));
}
public Task SpaceUploadDataStreamAsync(ApiSession apiSession, SpaceUploadDataStreamRequest spaceUploadFileRequest, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
if (spaceUploadFileRequest == null)
{
throw new ArgumentNullException(nameof(spaceUploadFileRequest));
}
return(Wrapped(async(token) =>
{
Action <FileTransferProgressEventArgs> onSendProgress = (data) =>
{
OnDataUploadProgress?.Invoke(this, data);
};
var sendStreamData = new SendFileStreamData(
spaceUploadFileRequest.DataStream,
spaceUploadFileRequest.FileName,
spaceUploadFileRequest.FileSize);
var apiResult =
spaceUploadFileRequest.OverwriteExistingFile ?
await _lowLevelApiClient.WebFilesPutFileStreamAsync(apiSession, spaceUploadFileRequest.ServerFolder, sendStreamData, onSendProgress, token) :
await _lowLevelApiClient.WebFilesPostFileStreamAsync(apiSession, spaceUploadFileRequest.ServerFolder, sendStreamData, onSendProgress, token);
FailIfError(apiResult);
return Task.FromResult(0);
}, cancellationToken, OperationType.FileTransfer));
}
public static void SaveApiSession(CMSDataContext db, User user, bool updatePin, int?pin)
{
var apiSession = db.ApiSessions.Where(s => s.UserId == user.UserId).SingleOrDefault();
if (apiSession != null)
{
apiSession.LastAccessedDate = DateTime.Now;
if (updatePin)
{
apiSession.Pin = pin;
}
}
else
{
var now = DateTime.Now;
apiSession = new ApiSession {
SessionToken = Guid.NewGuid(),
LastAccessedDate = now,
CreatedDate = now,
Pin = pin,
UserId = user.UserId,
};
db.ApiSessions.InsertOnSubmit(apiSession);
}
db.SubmitChanges();
}
public async Task <ApiResult <bool> > WebFileExistsAsync(ApiSession apiSession, string serverFilePath, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
var spaceName = apiSession.SpaceName;
var url = UrlHelper.JoinUrl("space", spaceName, "files", serverFilePath);
var apiResult = await apiClient.HeadAsync <NoContentResult>(url, null, apiSession.ToHeadersCollection(), cancellationToken);
// http ok or http no content means that file exists
if (apiResult.IsSucceed)
{
return(ApiResult <bool> .Ok(true));
}
else
{
// if not found, return Ok with false result
if (apiResult.Error is MorphApiNotFoundException)
{
return(ApiResult <bool> .Ok(false));
}
else
{
// some error occured - return internal error from api result
return(ApiResult <bool> .Fail(apiResult.Error));
}
}
}
public void AuthenticateMobileWithSessionTokenTest()
{
var username = RandomString();
var password = RandomString();
var user = CreateUser(username, password);
var requestManager = FakeRequestManager.Create();
var sessionToken = new ApiSession
{
CreatedDate = DateTime.Now,
LastAccessedDate = DateTime.Now,
SessionToken = Guid.NewGuid(),
UserId = user.UserId,
};
db.ApiSessions.InsertOnSubmit(sessionToken);
db.SubmitChanges();
requestManager.CurrentHttpContext.Request.Headers["SessionToken"] = sessionToken.SessionToken.ToString();
var membershipProvider = new MockCMSMembershipProvider {
ValidUser = true
};
var roleProvider = new MockCMSRoleProvider();
CMSMembershipProvider.SetCurrentProvider(membershipProvider);
CMSRoleProvider.SetCurrentProvider(roleProvider);
var result = AccountModel.AuthenticateMobile(requestManager.CurrentDatabase, requestManager.CurrentImageDatabase);
result.ErrorMessage.ShouldBeNullOrEmpty();
result.IsValid.ShouldBeTrue();
result.Status.ShouldBe(UserValidationStatus.Success);
}
public static void SaveApiSession(User user, bool updatePin, int?pin)
{
var apiSession = user.ApiSessions.SingleOrDefault();
if (apiSession != null)
{
apiSession.LastAccessedDate = DateTime.Now;
if (updatePin)
{
apiSession.Pin = pin;
}
}
else
{
var now = DateTime.Now;
apiSession = new ApiSession();
apiSession.SessionToken = Guid.NewGuid();
apiSession.LastAccessedDate = now;
apiSession.CreatedDate = now;
apiSession.Pin = pin;
user.ApiSessions.Add(apiSession);
}
DbUtil.Db.SubmitChanges();
}
public Task <ApiResult <SpaceBrowsingResponseDto> > WebFilesBrowseSpaceAsync(ApiSession apiSession, string folderPath, CancellationToken cancellationToken)
{
var spaceName = apiSession.SpaceName;
var url = UrlHelper.JoinUrl("space", spaceName, "browse", folderPath);
return(apiClient.GetAsync <SpaceBrowsingResponseDto>(url, null, apiSession.ToHeadersCollection(), cancellationToken));
}
public Task <SpaceTask> GetTaskAsync(ApiSession apiSession, Guid taskId, CancellationToken cancellationToken)
{
return(Wrapped(async(token) =>
{
var apiResult = await _lowLevelApiClient.GetTaskAsync(apiSession, taskId, token);
return MapOrFail(apiResult, (dto) => SpaceTaskMapper.MapFull(dto));
}, cancellationToken, OperationType.ShortOperation));
}
public Task <SpaceTasksList> GetTasksListAsync(ApiSession apiSession, CancellationToken cancellationToken)
{
return(Wrapped(async(token) =>
{
var apiResult = await _lowLevelApiClient.GetTasksListAsync(apiSession, token);
return MapOrFail(apiResult, (dto) => TasksListDtoMapper.MapFromDto(dto));
}, cancellationToken, OperationType.ShortOperation));
}
public Task AcknowledgeWorkflowResultAsync(ApiSession apiSession, string resultToken, CancellationToken cancellationToken)
{
return(Wrapped(async(token) =>
{
await _lowLevelApiClient.AcknowledgeWorkflowResultAsync(apiSession, resultToken, token);
return Task.FromResult(0);
}, cancellationToken, OperationType.ShortOperation));
}
internal ApiData(ApiSession rpSession, string rpApi, IDictionary <string, string> rpParameters, JObject rpJson)
{
Session = rpSession;
Api = rpApi;
Parameters = rpParameters;
Json = rpJson;
}
internal virtual void Process(ApiSession rpSession, JObject rpJson)
{
var rResultCode = (int)rpJson["api_result"];
if (rResultCode != 1)
{
throw new ApiFailedException(rResultCode);
}
}
public static HeadersCollection ToHeadersCollection(this ApiSession apiSession)
{
var collection = new HeadersCollection();
if (apiSession != null && !apiSession.IsAnonymous && !apiSession.IsClosed)
{
collection.Add(ApiSession.AuthHeaderName, apiSession.AuthToken);
}
return(collection);
}
public Task <ApiResult <NoContentResult> > AuthLogoutAsync(ApiSession apiSession, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
var url = "auth/logout";
return(apiClient.PostAsync <NoContentRequest, NoContentResult>(url, null, null, apiSession.ToHeadersCollection(), cancellationToken));
}
public Task <ApiResult <FetchFileStreamData> > WebFilesDownloadFileAsync(ApiSession apiSession, string serverFilePath, Action <FileTransferProgressEventArgs> onReceiveProgress, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
var spaceName = apiSession.SpaceName;
var url = UrlHelper.JoinUrl("space", spaceName, "files", serverFilePath);
return(apiClient.RetrieveFileGetAsync(url, null, apiSession.ToHeadersCollection(), onReceiveProgress, cancellationToken));
}
public Task <ApiResult <ValidateTasksResponseDto> > ValidateTasksAsync(ApiSession apiSession, ValidateTasksRequestDto validateTasksRequestDto, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
var spaceName = apiSession.SpaceName;
var url = "commands/validatetasks";
return(apiClient.PostAsync <ValidateTasksRequestDto, ValidateTasksResponseDto>(url, validateTasksRequestDto, null, apiSession.ToHeadersCollection(), cancellationToken));
}
static void ProcessCore(ApiSession rpSession)
{
var rApi = rpSession.DisplayUrl;
var rRequest = Uri.UnescapeDataString(rpSession.RequestBodyString);
var rResponse = rpSession.ResponseBodyString;
try
{
var rContent = rResponse.Replace("svdata=", string.Empty);
ApiParserBase rParser;
if (!rContent.IsNullOrEmpty() && rContent.StartsWith("{") && r_Parsers.TryGetValue(rApi, out rParser))
{
ListDictionary <string, string> rParameters = null;
if (!rRequest.IsNullOrEmpty() && rRequest.Contains('&'))
{
rParameters = new ListDictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var rParameter in rRequest.Split('&').Where(r => r.Length > 0).Select(r => r.Split('=')))
{
rParameters.Add(rParameter[0], rParameter[1]);
}
}
var rJson = JObject.Parse(rContent);
var rResultCode = (int)rJson["api_result"];
if (rResultCode != 1)
{
Logger.Write(LoggingLevel.Error, string.Format(StringResources.Instance.Main.Log_Exception_API_Failed, rApi, rResultCode));
return;
}
var rData = new ApiInfo(rpSession, rApi, rParameters, rJson);
rParser.Process(rData);
}
}
catch (AggregateException e) when(e.InnerExceptions.Count == 1)
{
Logger.Write(LoggingLevel.Error, string.Format(StringResources.Instance.Main.Log_Exception_API_ParseException, e.InnerExceptions[0].Message));
rpSession.ErrorMessage = e.ToString();
HandleException(rpSession, e);
}
catch (Exception e)
{
Logger.Write(LoggingLevel.Error, string.Format(StringResources.Instance.Main.Log_Exception_API_ParseException, e.Message));
rpSession.ErrorMessage = e.ToString();
HandleException(rpSession, e);
}
}
/// <summary>
/// Retrieves space status
/// </summary>
/// <param name="apiSession">api session</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <SpaceStatus> GetSpaceStatusAsync(ApiSession apiSession, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
return(Wrapped(async(token) =>
{
var apiResult = await _lowLevelApiClient.SpacesGetSpaceStatusAsync(apiSession, apiSession.SpaceName, token);
return MapOrFail(apiResult, (dto) => SpaceStatusMapper.MapFromDto(dto));
}, cancellationToken, OperationType.ShortOperation));
}
/// <summary>
/// Prerforms browsing the Space
/// </summary>
/// <param name="apiSession">api session</param>
/// <param name="folderPath">folder path like /path/to/folder</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <SpaceBrowsingInfo> SpaceBrowseAsync(ApiSession apiSession, string folderPath, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
return(Wrapped(async(token) =>
{
var apiResult = await _lowLevelApiClient.WebFilesBrowseSpaceAsync(apiSession, folderPath, token);
return MapOrFail(apiResult, (dto) => SpaceBrowsingMapper.MapFromDto(dto));
}, cancellationToken, OperationType.ShortOperation));
}
/// <summary>
/// Download file from server
/// </summary>
/// <param name="apiSession">api session</param>
/// <param name="remoteFilePath">Path to the remote file. Like /some/folder/file.txt </param>
/// <param name="streamToWriteTo">stream for writing. You should dispose the stream by yourself</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>returns file info</returns>
public async Task <DownloadFileInfo> DownloadFileAsync(ApiSession apiSession, string remoteFilePath, Stream streamToWriteTo, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
DownloadFileInfo fileInfo = null;
await DownloadFileAsync(apiSession, remoteFilePath, (fi) => { fileInfo = fi; return(true); }, streamToWriteTo, cancellationToken);
return(fileInfo);
}
public async Task <SpaceTask> GetTaskAsync(ApiSession apiSession, Guid taskId, CancellationToken cancellationToken)
{
var nvc = new NameValueCollection();
nvc.Add("_", DateTime.Now.Ticks.ToString());
var url = UrlHelper.JoinUrl("space", apiSession.SpaceName, "tasks", taskId.ToString("D"));
using (var response = await GetHttpClient().SendAsync(BuildHttpRequestMessage(HttpMethod.Get, url, null, apiSession), cancellationToken))
{
var dto = await HandleResponse <SpaceTaskDto>(response);
return(SpaceTaskMapper.MapFull(dto));
}
}
public static void SaveApiSession(User user, bool updatePin, int? pin)
{
var apiSession = user.ApiSessions.SingleOrDefault();
if (apiSession != null)
{
apiSession.LastAccessedDate = DateTime.Now;
if (updatePin)
apiSession.Pin = pin;
}
else
{
var now = DateTime.Now;
apiSession = new ApiSession();
apiSession.SessionToken = Guid.NewGuid();
apiSession.LastAccessedDate = now;
apiSession.CreatedDate = now;
apiSession.Pin = pin;
user.ApiSessions.Add(apiSession);
}
DbUtil.Db.SubmitChanges();
}
