private ResultError CreateResultError(JObject value)
{
var result = (ResultError)null;
if (value.Property("error") != null)
{
var error = (JObject)value.Property("error").Value;
result = new ResultError()
{
Message = error.Value <string>("message"),
Code = error.Value <int>("code"),
ErrorSubcode = error.Value <int>("error_subcode"),
FBTraceId = error.Value <string>("fbtrace_id"),
Type = error.Value <string>("type")
};
}
return(result);
}
public JsonResult Get(long requestid)
{
{
try
{
var req = _repository.GetRequestByID(_manager.UserID, requestid);
//var lst = new List<tb_request_escort>()
//{ new tb_request_escort() { RequestorBadgeNumber = _manager.UserID, RequestID = requestid },
// new tb_request_escort() { RequestorBadgeNumber = _manager.UserID, RequestID = requestid } };
if (req == null)
{
return(Json(null));
}
else
{
var vm = Mapper.Map <List <BadgeRequestEscortViewModel> >(req.RequestEscorts);
return(Json(vm));
}
}
catch (Exception e)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
var apierr = ResultError.CreateFromException("Error getting escorts for request " + requestid, HttpStatusCode.BadRequest, e);
_logger.LogError(apierr.ToString());
return(Json(apierr));
}
}
}
public void Initialize_Error_HasOne()
{
var resultError = new ResultError(CreateErrorTest());
Assert.False(resultError.OkStatus);
Assert.True(resultError.HasErrors);
Assert.Single(resultError.Errors);
}
public void Initialize_Base_OkStatus()
{
var resultError = new ResultError();
Assert.True(resultError.OkStatus);
Assert.False(resultError.HasErrors);
Assert.Empty(resultError.Errors);
}
public void ResultErrorBindOk_Ok_NoError()
{
var initialResult = new ResultError();
var addingResult = new ResultError();
var result = initialResult.ResultErrorBindOk(() => addingResult);
Assert.True(result.OkStatus);
}
public async Task ResultErrorBindOkTaskAsync_Ok_NoError()
{
var initialResult = ResultErrorFactory.CreateTaskResultError();
var addingResult = new ResultError();
var result = await initialResult.ResultErrorBindOkTaskAsync(() => addingResult);
Assert.True(result.OkStatus);
}
public CheckUserCredentialsResult(bool?isAuthorized = null, ResultError error = null)
{
Error = error;
if (Error == null && isAuthorized != null)
{
Success = new CheckUserCredentialsSuccess(isAuthorized.Value);
}
}
public void ResultErrorBindOkBad_Ok()
{
var initialResult = new ResultError();
var addingResult = new ResultError();
var result = initialResult.ResultErrorBindOkBad(() => addingResult,
errors => new ResultError(CreateErrorTest()));
Assert.True(result.OkStatus);
}
public void WithNestedType()
{
var value = NestedClass.Lululu.One;
var resourceManager = Strings.ResourceManager;
var expected = "Hello World";
var result = new ResultError <NestedClass.Lululu>(value, resourceManager);
Assert.AreEqual(value, result.Code);
Assert.AreEqual(expected, result.DisplayMessage);
}
public void WithoutResourceManagerAndFormat()
{
var value = Lalala.Infinity;
var resourceManager = "here is a format => {0} <=";
var expected = "here is a format => aabb <=";
var result = new ResultError <Lalala>(value, resourceManager, "aabb");
Assert.AreEqual(value, result.Code);
Assert.AreEqual(expected, result.DisplayMessage);
}
public void WithoutResourceManager()
{
var value = Lalala.One;
var resourceManager = "Hello World";
var expected = "Hello World";
var result = new ResultError <Lalala>(value, resourceManager);
Assert.AreEqual(value, result.Code);
Assert.AreEqual(expected, result.DisplayMessage);
}
public async Task ResultErrorBindOkBadAsync_Ok()
{
var initialResult = new ResultError();
var addingResult = new ResultError();
var result = await initialResult.ResultErrorBindOkBadAsync(() => ResultErrorFactory.CreateTaskResultError(addingResult),
errors => ResultErrorFactory.CreateTaskResultErrorAsync(CreateErrorTest()));
Assert.True(result.OkStatus);
}
public async Task ResultErrorVoidOkAsync_Ok_CallVoid()
{
var resultOk = new ResultError();
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = await resultOk.ResultErrorVoidOkAsync(() => voidObjectMock.Object.TestVoidAsync());
Assert.True(resultAfterVoid.Equals(resultOk));
voidObjectMock.Verify(voidObject => voidObject.TestVoidAsync(), Times.Once);
}
public Result(bool success, ResultError errorCode)
{
Debug.Assert((success && errorCode == ResultError.ErrorNone) || (!success && errorCode != ResultError.ErrorNone));
Operation = null;
AsyncResult = null;
Success = success;
ErrorCode = errorCode;
CompletedEvent = null;
}
public static StatusResult Failed(IEnumerable <CommandError> errors, string commandId = null, string state = null, string stateMessage = null)
=> new StatusResult
{
CommandId = commandId,
Code = StatusCodes.Status200OK,
Status = "Failed",
State = string.IsNullOrWhiteSpace(state) ? null : state,
StateMessage = string.IsNullOrWhiteSpace(stateMessage) ? null : stateMessage,
Errors = errors?.Select(error => ResultError.Failed(error)).ToList() ?? new List <ResultError>()
};
public void ToResultValue_OkStatus()
{
var resultNoError = new ResultError();
const string value = "OkStatus";
var resultValue = resultNoError.ToResultValue(value);
Assert.True(resultValue.OkStatus);
Assert.Equal(value, resultValue.Value);
}
public static SearchResult <P> WasBadRequest
(ResultError error)
{
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
return(new BadRequest(new [] { error }));
}
public static AddResult <P> WasError
(ResultError error)
{
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
return(new Error(new [] { error }));
}
public void ConcatErrors_TotalTwo()
{
var resultErrorInitial = new ResultError(CreateErrorTest());
var errorToConcat = CreateErrorTest();
var resultErrorConcatted = resultErrorInitial.ConcatErrors(errorToConcat);
Assert.True(resultErrorConcatted.HasErrors);
Assert.Equal(2, resultErrorConcatted.Errors.Count);
Assert.True(errorToConcat.Equals(resultErrorConcatted.Errors.Last()));
}
public async Task DeleteAsync_Ok()
{
var resultTest = new ResultError();
var restClient = RestClientMock.DeleteRestClient(resultTest);
var testTransferConverter = TestTransferConverter;
var testRestService = new TestRestService(restClient.Object, testTransferConverter);
var result = await testRestService.DeleteAsync();
Assert.True(result.OkStatus);
}
public async Task ToResultBindValue_OkStatus()
{
var resultNoError = new ResultError();
const string value = "OkStatus";
var resultValue = ResultValueFactory.CreateTaskResultValue(value);
var resultValueAfter = await resultNoError.ToResultBindValueAsync(resultValue);
Assert.True(resultValueAfter.OkStatus);
Assert.Equal(value, resultValueAfter.Value);
}
public void ResultErrorVoidOkBad_Ok()
{
var resultOk = new ResultError();
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = resultOk.ResultErrorVoidOkBad(() => voidObjectMock.Object.TestVoid(),
errors => voidObjectMock.Object.TestNumberVoid(errors.Count));
Assert.True(resultAfterVoid.Equals(resultOk));
voidObjectMock.Verify(voidObject => voidObject.TestVoid(), Times.Once);
}
public void ResultErrorVoidOkWhere_Ok_OkPredicate_CallVoid()
{
var resultOk = new ResultError();
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = resultOk.ResultErrorVoidOkWhere(() => true,
action: () => voidObjectMock.Object.TestVoid());
Assert.True(resultAfterVoid.Equals(resultOk));
voidObjectMock.Verify(voidObject => voidObject.TestVoid(), Times.Once);
}
public async Task ResultErrorBindOkTaskAsync_Bad_NoError()
{
var initialError = CreateErrorTest();
var initialResult = ResultErrorFactory.CreateTaskResultError(initialError);
var addingResult = new ResultError();
var result = await initialResult.ResultErrorBindOkTaskAsync(() => addingResult);
Assert.True(result.HasErrors);
Assert.True(result.Equals(initialResult.Result));
}
public ResultAlbums ListAlbums()
{
ResultAlbums resultListAlbums = new ResultAlbums();
List <AlbumData> listAlbums = new List <AlbumData>();
try
{
Uri uri = new Uri(GoogleConstants.URL_LIST_ALBUMS);
RestClient client = new RestClient(uri);
RestRequest request = new RestRequest(Method.GET);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Authorization", "Bearer " + this.accessToken);
bool hasMoreAlbums = true;
while (hasMoreAlbums)
{
IRestResponse response = client.Execute(request);
if (response.IsSuccessful)
{
ResultAlbums resultAlbums = JsonConvert.DeserializeObject <ResultAlbums>(response.Content);
listAlbums.AddRange(resultAlbums.Albums);
resultListAlbums.ResultCode = response.StatusCode.ToString();
resultListAlbums.ResultMessage = (response.ErrorMessage == "null") ? string.Empty : response.ErrorMessage;
if (resultAlbums.NextPageToken != null)
{
request.AddParameter("pageToken", resultAlbums.NextPageToken);
}
else
{
resultListAlbums.Albums = listAlbums;
hasMoreAlbums = false;
}
}
else
{
ResultError resultError = JsonConvert.DeserializeObject <ResultError>(response.Content);
resultListAlbums.ResultCode = response.StatusCode.ToString();
resultListAlbums.ResultMessage = (resultError.Error != null) ? resultError.Error.Message : "Erro";
hasMoreAlbums = false;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex.Message);
}
return(resultListAlbums);
}
public void ToResultValueBind_OkStatus()
{
var resultNoError = new ResultError();
const string value = "OkStatus";
var resultValue = new ResultValue <string>(value);
var resultValueAfter = resultNoError.ToResultBindValue(resultValue);
Assert.True(resultValueAfter.OkStatus);
Assert.Equal(value, resultValueAfter.Value);
}
public void ToNoContentActionResult_OkRequest()
{
var result = new ResultError();
var actionResult = result.ToNoContentActionResult();
Assert.IsType <NoContentResult>(actionResult);
var noContentResult = (NoContentResult)actionResult;
Assert.Equal(StatusCodes.Status204NoContent, noContentResult.StatusCode);
}
public async Task ResultErrorVoidOkWhereAsync_Ok_BadPredicate_NotCallVoid()
{
var resultOk = new ResultError();
var voidObjectMock = new Mock <IVoidObject>();
var resultAfterVoid = await resultOk.ResultErrorVoidOkWhereAsync(() => false,
action : () => voidObjectMock.Object.TestVoidAsync());
Assert.True(resultAfterVoid.Equals(resultOk));
voidObjectMock.Verify(voidObject => voidObject.TestVoidAsync(), Times.Never);
}
public virtual void SetCompleted(bool success, ResultError errorCode)
{
Success = success;
ErrorCode = errorCode;
#if DEBUG
#elif TRACE
Traces = Debugging.CollectTraces();
#endif
CompletedEvent.Set();
}
public void ResultErrorBindOk_Bad_NoError()
{
var initialError = CreateErrorTest();
var initialResult = new ResultError(initialError);
var addingResult = new ResultError();
var result = initialResult.ResultErrorBindOk(() => addingResult);
Assert.True(result.HasErrors);
Assert.True(result.Equals(initialResult));
}
