public ActionResult Delete(string id)
{
RequestResultModel response = new RequestResultModel();
try
{
var user = UserManager.FindById(id);
if (user != null)
{
user.Deleted = true;
UserManager.Update(user);
response.Message = GetMessage(Data.Enums.ResponseMessage.Delete);
return(ReturnSuccessResponse(response));
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
public ActionResult DeleteOtherExpense(int id)
{
RequestResultModel response = new RequestResultModel();
try
{
var model = Context.OtherExpenceRepo.GetByID(id);
int saleId = model.SaleId.Value;
if (model != null)
{
Context.OtherExpenceRepo.Delete(model);
Context.Save();
UpdateSale(saleId);
response.Message = GetMessage(Data.Enums.ResponseMessage.Delete);
return(ReturnSuccessResponse(response));
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
public JsonResult RemoveAuditEvents(List <int> Items)
{
RequestResultModel Model = new RequestResultModel();
if (Items != null)
{
foreach (int Item in Items)
{
AuditEvents.GetBy(Item).Delete();
}
Model.Message = "Selected audit items have been removed successfully.";
}
else
{
AuditEvents.RemoveAll();
Model.Message = "All audit items have been removed successfully.";
}
Model.InfoType = RequestResultInfoType.Success;
Model.Title = "Removing Audit Items";
return(Json(new
{
NotifyType = NotifyType.PageInline,
Html = this.RenderPartialView(@"_RequestResultPageInLine", Model)
}, JsonRequestBehavior.AllowGet));
}
public async Task StubContainer_GetRequestResultsByStubIdAsync_HappyFlow()
{
// arrange
var request1 = new RequestResultModel
{
ExecutingStubId = "stub1", RequestBeginTime = DateTime.Now.AddSeconds(-2)
};
var request2 = new RequestResultModel
{
ExecutingStubId = "stub2", RequestBeginTime = DateTime.Now.AddSeconds(-2)
};
var request3 = new RequestResultModel
{
ExecutingStubId = "stub1", RequestBeginTime = DateTime.Now.AddSeconds(-1)
};
var requests = new[] { request1, request2, request3 };
var stubSource = new Mock <IWritableStubSource>();
stubSource
.Setup(m => m.GetRequestResultsAsync())
.ReturnsAsync(requests);
_stubSources.Add(stubSource.Object);
// act
var result = (await _context.GetRequestResultsByStubIdAsync("stub1")).ToArray();
// assert
Assert.AreEqual(2, result.Length);
Assert.AreEqual(requests[0], result[1]);
Assert.AreEqual(requests[2], result[0]);
}
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
RequestResultModel response = new RequestResultModel();
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
response.Message = GetMessage(Data.Enums.ResponseMessage.Update);
return(ReturnSuccessResponse(response));
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
/// <inheritdoc />
public async Task AddRequestResultAsync(RequestResultModel requestResult, ResponseModel responseModel)
{
using var ctx = _databaseContextFactory.CreateDatabaseContext();
var hasResponse = responseModel != null;
requestResult.HasResponse = hasResponse;
var json = JsonConvert.SerializeObject(requestResult);
await ctx.ExecuteAsync(_queryStore.AddRequestQuery,
new
{
requestResult.CorrelationId,
requestResult.ExecutingStubId,
requestResult.RequestBeginTime,
requestResult.RequestEndTime,
Json = json,
HasResponse = hasResponse
});
if (hasResponse)
{
await ctx.ExecuteAsync(_queryStore.AddResponseQuery,
new
{
requestResult.CorrelationId,
responseModel.StatusCode,
Headers = JsonConvert.SerializeObject(responseModel.Headers),
Body = responseModel.Body != null ? Convert.ToBase64String(responseModel.Body) : string.Empty,
responseModel.BodyIsBinary
});
}
}
public RequestResultDTO Map(RequestResultModel requestResultModel)
{
return(new RequestResultDTO {
IsSuccess = requestResultModel.IsSuccess,
Message = requestResultModel.Message
});
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
var pair = request.RequestParameters.Headers.FirstOrDefault(p =>
p.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase));
var contentType = pair.Value;
if (string.IsNullOrWhiteSpace(contentType))
{
return(Task.FromResult(false));
}
if (!contentType.Equals("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase))
{
return(Task.FromResult(false));
}
// If the body condition is already set, clear it here.
stub.Conditions.Body = new string[0];
var reader = new FormReader(request.RequestParameters.Body);
var form = reader.ReadForm();
stub.Conditions.Form = form.Select(f => new StubFormModel
{
Key = f.Key,
Value = f.Value
});
return(Task.FromResult(true));
}
public async Task StubContainer_AddRequestResultAsync_HappyFlow()
{
// arrange
var stubSource = new Mock <IWritableStubSource>();
var stub = new StubModel {
Id = "stub1", Tenant = "tenant1"
};
stubSource
.Setup(m => m.GetStubsAsync())
.ReturnsAsync(new[] { stub });
var request = new RequestResultModel {
ExecutingStubId = stub.Id
};
stubSource
.Setup(m => m.AddRequestResultAsync(request))
.Returns(Task.CompletedTask);
_stubSources.Add(stubSource.Object);
// act
await _context.AddRequestResultAsync(request);
// assert
stubSource.Verify(m => m.AddRequestResultAsync(request), Times.Once);
stubSource.Verify(m => m.CleanOldRequestResultsAsync(), Times.Once);
Assert.AreEqual(stub.Tenant, request.StubTenant);
}
public JsonResult SaveFieldGroup(int GroupID, string Name, string Description, string Order, bool IsActive, bool AdminUseOnly)
{
ProfileFieldGroup fieldGroup = ProfileFieldGroups.GetBy(GroupID);
String Message = "";
if (fieldGroup.FieldGroupName.Trim().ToLower() != Name.Trim().ToLower())
{
if (ProfileFieldGroups.GetByName(Name.Trim()).FieldGroupID > 0)
{
Message = "The group \"" + Name + "\" already exists.";
}
}
if (fieldGroup.FieldGroupName.Trim().ToLower().Length == 0)
{
Message = "The group name should not be empty.";
}
if (Message != "")
{
RequestResultModel _model = new RequestResultModel();
_model.InfoType = RequestResultInfoType.ErrorOrDanger;
_model.Message = Message;
AuditEvent.AppEventWarning(Profile.Member.Email, Message);
return(Json(new
{
NotifyType = NotifyType.DialogInline,
Html = this.RenderPartialView(@"_RequestResultDialogInLine", _model),
}, JsonRequestBehavior.AllowGet));
}
fieldGroup.FieldGroupName = Name;
fieldGroup.FieldGroupDescription = Description;
fieldGroup.IsActive = IsActive ? 1 : 0;
fieldGroup.AdminUseOnly = AdminUseOnly ? 1 : 0;
fieldGroup.Save();
if (GroupID > 0)
{
AuditEvent.AppEventSuccess(Profile.Member.Email, String.Format("The \"{0}\" profile group has been updated.", Name));
}
else
{
AuditEvent.AppEventSuccess(Profile.Member.Email, String.Format("The \"{0}\" profile group has been added.", Name));
}
if (Order != "")
{
ProfileFieldGroups.UpdateOrder(Order);
}
return(Json(new
{
NotifyType = -1,
Html = "",
}, JsonRequestBehavior.AllowGet));
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
var pair = request.RequestParameters.Headers.FirstOrDefault(p =>
p.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrWhiteSpace(pair.Value))
{
return(Task.FromResult(false));
}
var value = pair.Value;
value = value.Replace("Basic ", string.Empty);
var basicAuth = Encoding.UTF8.GetString(Convert.FromBase64String(value));
var parts = basicAuth.Split(':');
if (parts.Length != 2)
{
return(Task.FromResult(false));
}
stub.Conditions.BasicAuthentication = new StubBasicAuthenticationModel
{
Username = parts[0],
Password = parts[1]
};
// Make sure the original Authorization header is removed here.
stub.Conditions.Headers = stub.Conditions.Headers
.Where(h => !h.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
.ToDictionary(d => d.Key, d => d.Value);
return(Task.FromResult(true));
}
public async Task BasicAuthenticationHandler_HandleStubGenerationAsync_HappyFlow()
{
// Arrange
const string username = "******";
const string password = "******";
var auth = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}"));
var stub = new StubModel
{
Conditions = { Headers = new Dictionary <string, string> {
{ "Authorization", auth }
} }
};
var request = new RequestResultModel
{
RequestParameters = new RequestParametersModel
{
Headers = new Dictionary <string, string>
{
{ "Authorization", auth }
}
}
};
// Act
var result = await _handler.HandleStubGenerationAsync(request, stub);
// Assert
Assert.IsTrue(result);
Assert.AreEqual(username, stub.Conditions.BasicAuthentication.Username);
Assert.AreEqual(password, stub.Conditions.BasicAuthentication.Password);
Assert.IsFalse(stub.Conditions.Headers.Any());
}
public ActionResult Delete(int id)
{
RequestResultModel response = new RequestResultModel();
try
{
var rate = Context.RateRepo.GetByID(id);
if (rate != null)
{
rate.Deleted = true;
Context.RateRepo.Update(rate);
Context.Save();
response.Message = GetMessage(Data.Enums.ResponseMessage.Delete);
return(ReturnSuccessResponse(response));
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
public async Task RestApiIntegration_Request_GetResponse_RequestFound_ShouldReturnResponse()
{
// Arrange
var correlation = Guid.NewGuid().ToString();
var request = new RequestResultModel {
CorrelationId = correlation
};
var responseModel = new ResponseModel {
Body = new byte[] { 1, 2, 3 }, StatusCode = 200, BodyIsBinary = true
};
StubSource.RequestResultModels.Add(request);
StubSource.StubResponses.Add(responseModel);
StubSource.RequestResponseMap.Add(request, responseModel);
// Act
using var response = await Client.GetAsync($"{TestServer.BaseAddress}ph-api/requests/{correlation}/response");
var content = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <ResponseDto>(content);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Body.SequenceEqual(responseModel.Body));
Assert.AreEqual(responseModel.StatusCode, result.StatusCode);
Assert.AreEqual(responseModel.BodyIsBinary, result.BodyIsBinary);
}
public async Task FormHandler_HandleStubGenerationAsync_HappyFlow()
{
// Arrange
const string contentType = "application/x-www-form-urlencoded";
const string form = "form1=val1&form2=val2";
var request = new RequestResultModel
{
RequestParameters = new RequestParametersModel
{
Headers = new Dictionary <string, string>
{
{ "Content-Type", contentType }
},
Body = form
}
};
var stub = new StubModel();
// Act
var result = await _handler.HandleStubGenerationAsync(request, stub);
// Assert
Assert.IsTrue(result);
var formDict = stub.Conditions.Form.ToDictionary(f => f.Key, f => f.Value);
Assert.AreEqual("val1", formDict["form1"]);
Assert.AreEqual("val2", formDict["form2"]);
Assert.IsFalse(stub.Conditions.Body.Any());
}
public async Task HeaderHandler_HandleStubGenerationAsync_HappyFlow()
{
// Arrange
var request = new RequestResultModel
{
RequestParameters = new RequestParametersModel
{
Headers = new Dictionary <string, string>
{
{ "Postman-Token", Guid.NewGuid().ToString() },
{ "Host", "httplaceholder.com" },
{ "X-Api-Key", "123" },
{ "X-Bla", "bla" }
}
}
};
var stub = new StubModel();
// Act
var result = await _handler.HandleStubGenerationAsync(request, stub);
// Assert
Assert.IsTrue(result);
Assert.AreEqual(2, stub.Conditions.Headers.Count);
Assert.AreEqual("123", stub.Conditions.Headers["X-Api-Key"]);
Assert.AreEqual("bla", stub.Conditions.Headers["X-Bla"]);
}
public ActionResult CreateEdit(Rate model)
{
RequestResultModel response = new RequestResultModel();
try
{
if (ModelState.IsValid)
{
if (model.Id > 0)
{
var toUpdate = Context.RateRepo.GetByID(model.Id);
toUpdate.DestinationId = model.DestinationId;
toUpdate.DriverCost = model.DriverCost;
toUpdate.TruckId = model.TruckId;
toUpdate.Amount = model.Amount;
toUpdate.WaterCost = model.WaterCost;
toUpdate.HelperCost = model.HelperCost;
Context.RateRepo.Update(toUpdate);
Context.Save();
//foreach (var sale in toUpdate.Sales)
//{
// sale.Less = toUpdate.DriverCost + toUpdate.WaterCost + toUpdate.HelperCost;
// Context.SaleRepo.Update(sale);
// Context.Save();
//}
response.Message = GetMessage(Data.Enums.ResponseMessage.Update);
response.ReturnId = toUpdate.Id.ToString();
}
else
{
var toInsert = model;
toInsert.Deleted = false;
Context.RateRepo.Insert(toInsert);
Context.Save();
response.Message = GetMessage(Data.Enums.ResponseMessage.Save);
response.ReturnId = toInsert.Id.ToString();
}
return(ReturnSuccessResponse(response));
}
else
{
response.Message = GetValidationErrors();
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
protected ActionResult ReturnSuccessResponse(RequestResultModel requestModel)
{
requestModel.Title = "Success!";
requestModel.Success = true;
requestModel.Html = this.RenderPartialView(@"_RequestResultPageInlineMessage", requestModel);
requestModel.HideInSeconds = 2;
return(Json(requestModel, JsonRequestBehavior.AllowGet));
}
public RequestLogger(IDateTime dateTime)
{
_dateTime = dateTime;
_result = new RequestResultModel
{
RequestBeginTime = _dateTime.UtcNow
};
}
public Task AddRequestResultAsync(RequestResultModel requestResult)
{
lock (_lock)
{
RequestResultModels.Add(requestResult);
return(Task.CompletedTask);
}
}
public Task AddRequestResultAsync(RequestResultModel requestResult)
{
var path = EnsureAndGetRequestsFolder();
var filePath = Path.Combine(path, $"{requestResult.CorrelationId}.json");
var contents = JsonConvert.SerializeObject(requestResult);
_fileService.WriteAllText(filePath, contents);
return(Task.CompletedTask);
}
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
RequestResultModel requestModel = new RequestResultModel();
requestModel.Message = "Invalid Email. Please contact the administrator.";
requestModel.Success = false;
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(model.Email);
if (user != null && UserManager.IsEmailConfirmed(user.Id) && IsUserInAdminRole(user.Id))
{
user.Profile = Context.UserProfileRepo.Get(s => s.Id == user.ProfileId, includeProperties: "UserImage").First();
model.FullName = user.Profile.FullName;
model.ImageName = Path.Combine(user.Profile.UserImage.Path, user.Profile.UserImage.Name);
model.Verified = user.EmailConfirmed == true ? true : false;
if (model.Verified)
{
model.IsReadOnlyEmail = true;
// Send an email with this link
string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
string messageBody = "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>";
await UserManager.SendEmailAsync(user.Id, "Reset Password", messageBody);
requestModel.Message = " Please check your email to reset your password.";
requestModel.Success = true;
}
else
{
requestModel.Message = "Is this your account? Please Continue if it is.";
requestModel.Success = true;
}
// Don't reveal that the user does not exist or is not confirmed
//return View("ForgotPasswordConfirmation");
}
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
// var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
// return RedirectToAction("ForgotPasswordConfirmation", "Account");
}
ViewBag.Response = this.RenderPartialView(@"_RequestResultPageInlineMessage", requestModel);
// If we got this far, something failed, redisplay form
return(View(model));
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
if (string.IsNullOrWhiteSpace(request.RequestParameters.Body))
{
return(Task.FromResult(false));
}
stub.Conditions.Body = new[] { request.RequestParameters.Body };
return(Task.FromResult(true));
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
if (string.IsNullOrWhiteSpace(request.RequestParameters.Method))
{
throw new InvalidOperationException("No HTTP method set; this is unexpected.");
}
stub.Conditions.Method = request.RequestParameters.Method;
return(Task.FromResult(true));
}
protected ActionResult ReturnValidationErrorResponse(RequestResultModel requestModel, object data)
{
requestModel.Title = "Validation Error(s)!";
requestModel.Success = false;
requestModel.Html = this.RenderPartialView(@"_RequestResultPageInlineMessage", requestModel);
requestModel.HideInSeconds = 2;
return(Json(new
{
requestModel
}, JsonRequestBehavior.AllowGet));
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
var uri = new Uri(request.RequestParameters.Url);
var host = uri.Host;
if (uri.Port != 80 && uri.Port != 443)
{
host += $":{uri.Port}";
}
stub.Conditions.Host = host;
return(Task.FromResult(true));
}
public Task <bool> HandleStubGenerationAsync(RequestResultModel request, StubModel stub)
{
var uri = new Uri(request.RequestParameters.Url);
var query = QueryHelpers.ParseQuery(uri.Query);
if (!query.Any())
{
return(Task.FromResult(false));
}
stub.Conditions.Url.Query = query.ToDictionary(q => q.Key, q => q.Value.ToString());
return(Task.FromResult(true));
}
public ActionResult CreateEdit(Sale model)
{
RequestResultModel response = new RequestResultModel();
try
{
if (ModelState.IsValid)
{
if (model.Id > 0)
{
var toUpdate = Context.SaleRepo.GetByID(model.Id);
toUpdate.RateId = model.RateId;
toUpdate.Gross = model.Gross;
toUpdate.Less = model.Less;
toUpdate.FuelCost = model.FuelCost;
toUpdate.Date = model.Date;
toUpdate.CalculateThenSet();
Context.SaleRepo.Update(toUpdate);
Context.Save();
response.Message = GetMessage(Data.Enums.ResponseMessage.Update);
response.ReturnId = toUpdate.Id.ToString();
}
else
{
var toInsert = model;
toInsert.UserId = User.Identity.Name;
toInsert.CalculateThenSet();
Context.SaleRepo.Insert(toInsert);
Context.Save();
response.Message = GetMessage(Data.Enums.ResponseMessage.Save);
response.ReturnId = toInsert.Id.ToString();
}
return(ReturnSuccessResponse(response));
}
else
{
response.Message = GetValidationErrors();
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
public ActionResult CreateEditOtherExpense(OtherExpence model)
{
RequestResultModel response = new RequestResultModel();
try
{
if (ModelState.IsValid)
{
if (model.Id > 0)
{
var toUpdate = Context.OtherExpenceRepo.GetByID(model.Id);
toUpdate.Name = model.Name;
toUpdate.Amount = model.Amount;
toUpdate.SaleId = model.SaleId;
Context.OtherExpenceRepo.Update(toUpdate);
Context.Save();
UpdateSale(toUpdate.SaleId.Value);
response.Message = GetMessage(Data.Enums.ResponseMessage.Update);
response.ReturnId = toUpdate.Id.ToString();
}
else
{
var toInsert = model;
Context.OtherExpenceRepo.Insert(toInsert);
Context.Save();
UpdateSale(toInsert.SaleId.Value);
response.Message = GetMessage(Data.Enums.ResponseMessage.Save);
response.ReturnId = toInsert.Id.ToString();
}
return(ReturnSuccessResponse(response));
}
else
{
response.Message = GetValidationErrors();
}
}
catch (Exception e)
{
response.Message = GetValidationErrors();
}
return(ReturnErrorResponse(response));
}
public JsonResult SetShowInSignUp(bool Flag, int FieldID)
{
ProfileFields.SetShowInSignUp(Flag, FieldID);
RequestResultModel _model = new RequestResultModel();
_model.InfoType = RequestResultInfoType.Success;
return(Json(new
{
NotifyType = NotifyType.PageInline,
Html = "",
}, JsonRequestBehavior.AllowGet));
}
