public ActionResult Plus18Check()
{
DB_A42A9B_Aveleijn2018Entities4 db = new DB_A42A9B_Aveleijn2018Entities4();
ResultVM result = new ResultVM();
result.IndicatieB_id = ViewBag.indicatieB_id;
result.Wet = ViewBag.wet;
result.Kenmerken_inwoner = ViewBag.kenmerken_inwoner;
result.Doel_ondersteuning = ViewBag.doel_ondersteuning;
result.Ondersteuning = ViewBag.ondersteuning;
result.IndicatieN_id = ViewBag.indicatieN_id;
result.GedragsProblematiek = ViewBag.gedragsProblematiek;
result.Context = ViewBag.context;
result.Escalatie = ViewBag.escalatie;
result.Motivatie = ViewBag.motivatie;
result.OndersteuningN = ViewBag.ondersteuning;
result.Veranderingen = ViewBag.veranderingen;
//TODO: Advies
if (ViewBag.totaalN)
{
}
return(View(result));
}
public CashRegisterService(IMapper mapper, IStockService stockService, IStockData stockData)
{
this.mapper = mapper;
this.stockService = stockService;
this.stockData = stockData;
result = new ResultVM();
}
public ActionResult SystemSend([Bind(Include = "Members,SelectedMembers,Message")] MessagesVM messagesVM)
{
if (messagesVM == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
messagesVM.Members = db.Users.OrderBy(user => user.Name).ToList();
for (int i = 0; i < messagesVM.Members.Count; i++)
{
if (messagesVM.SelectedMembers[i])
{
messagesVM.Message.To.Add(messagesVM.Members[i]);
}
}
ResultVM resultVM = new ResultVM();
if (messenger.SendMessageFromSystem(messagesVM.Message))
{
resultVM.ErrorOccurred = false;
resultVM.Title = "Send Successful";
resultVM.Message = "Your Notification has been sent successfully.";
resultVM.RedirectViewName = "Member";
resultVM.RedirectControllerName = "Home";
}
return(View("ResultPage", resultVM));
}
/// <summary>
/// Add an item to the cart
/// </summary>
/// <param name="itemId"></param>
/// <param name="buyerQuantity"></param>
/// <param name="pounds"></param>
public ResultVM AddItemToCart(uint code, ushort buyerQuantity, double pounds = 0)
{
var ResultVM = new ResultVM();
try
{
var item = stockData.GetItemByCode(code);
if (item != null && item.Units >= buyerQuantity)
{
var buyerItem = mapper.Map <BuyerItemVM>(item);
buyerItem.FreeUnits = GetFreeItemCount(buyerItem);
buyerItem.Price = GetFinalItemPrice(buyerItem);
stockService.ReduceStockAsUnits(buyerItem.Code, buyerItem.Units);
shoppingCart.Items.Add(buyerItem);
ResultVM.Message = Message.ItemAddedToCart;
}
else
{
ResultVM.Message = Message.InsufficientItemQuantity;
}
}
catch (Exception ex)
{
ResultVM.Message = Message.ItemNotAddedToCart;
throw;
}
return(ResultVM);
}
public void Create(ResultVM model)
{
_unitOfWork.Results.Create(new Result {
TimeStart = model.TimeStart, TotalScore = model.TotalScore, AccountId = model.AccountId, TestId = model.TestId
});
_unitOfWork.Save();
}
public List <ResultVM> GetAllResult()
{
Connection.Open();
Query = "SELECT et.StudentId as stdid, ct.CourseCode, ct.CourseName, gt.Grade FROM Enroll_tb as et INNER JOIN Course_tb" +
" as ct on et.CourseId = ct.Id LEFT JOIN Result_tb as rt on et.CourseId = rt.CourseId AND et.StudentId = rt.StudentId " +
"LEFT JOIN Grade_tb as gt on rt.GradeId = gt.Id";
Command = new SqlCommand(Query, Connection);
Reader = Command.ExecuteReader();
List <ResultVM> resultVms = new List <ResultVM>();
while (Reader.Read())
{
ResultVM aResultVm = new ResultVM()
{
StudentId = Convert.ToInt32(Reader["stdid"]),
CourseCode = Convert.ToString(Reader["CourseCode"]),
CourseName = Convert.ToString(Reader["CourseName"]),
Grade = Convert.ToString(Reader["Grade"])
};
resultVms.Add(aResultVm);
}
Reader.Close();
Connection.Close();
return(resultVms);
}
public ActionResult <ResultVM <AppUserVM> > ForgotPassword(string EmailId)
{
var resultVM = new ResultVM <bool>();
var result = accountBusiness.GetUserByEmailId(EmailId);
if (result.Success)
{
//string otp = string.Empty;
//while (userBusiness.CheckIfOTPExists(otp)) { otp = Common.GenerateRandomOTP(); };
//ResetPasswordModel resetPasswordModel = new ResetPasswordModel()
//{
// UserId = result.Data.Id,
// EmailId = result.Data.EmailId,
// OTP = otp
//};
//userBusiness.SaveResetOTP(resetPasswordModel);
string subject = "Reset Password";
string body = string.Format("Hi,< br />< br /> We got request for reset your account password.Please use below OTP to reset your password"
);
bool isSent = new Mailer()
.Subject(subject)
.Body(body)
.To(EmailId)
.Send();
resultVM.Success = isSent;
resultVM.Message = isSent ? Enums.ResetPasswordEmail : Enums.EmailError;
}
else
{
resultVM.Message = result.Message;
}
return(Ok(new { result = result }));
}
public JsonResult GetResultByStudentId(ResultVM aResultVm)
{
var result = aResultManager.GetAllResult();
var resultList = result.Where(r => r.StudentId == aResultVm.Id).ToList();
return(Json(resultList));
}
public ActionResult _CreatePositionPartial(PositionVM model)
{
if (!ModelState.IsValid)
{
// mock up error messages to display in json
string errors = "";
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(x => x.Errors);
foreach (var item in allErrors)
{
errors += item.ErrorMessage + "\n";
}
ViewBag.Errors = errors;
return(PartialView(model));
}
Result = User.CreatePosition(model);
if (!Result.Success)
{
ModelState.AddModelError("error", Result.ErrorMessage);
return(Json(new { Status = 0, Message = Result.ErrorMessage }));
//return PartialView(model);
}
TempData["SCC"] = "Position created!";
return(PartialView());
}
public ActionResult <ResultVM <AppUserVM> > LogIn(AppUserVM login)
{
var result = new ResultVM <AppUserVM>();
string Token = string.Empty;
//var user = await AuthenticateUser(login);
try
{
if (!ModelState.IsValid)
{
result.Message = ModelState.Values.SelectMany(s => s.Errors).FirstOrDefault().ErrorMessage;
result.StatusCode = Convert.ToInt32(Enums.StatusCode.BadRequest);
}
else
{
var resultModel = accountBusiness.UserExists(login.EmailId, login.Password);
mapper.Map(resultModel, result);
if (resultModel.Data != null)
{
Token = GenerateJSONWebToken();
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
result.StatusCode = (int)Enums.StatusCode.ServerError;
}
return(Ok(new { Token, result = result }));
}
public ActionResult SaveResult(ResultVM student)
{
ViewBag.Students = aResultManager.GetAllStudents();
ViewBag.Message = aResultManager.SaveResult(student);
ViewBag.Results = aResultManager.GetAllGrades();
return(View());
}
public ActionResult Edit(EmployeeVM objVM)
{
var resultVM = new ResultVM();
try
{
using (var objBLL = new EmployeeBLL())
{
objVM.Logo = Helper.FilePaths(Server.MapPath("~/content/employee/" + objVM.ID + "/img/"));
//objVM.LastActivityBy = ActiveUser.ID;
int id = objBLL.SaveData(objVM);
if (id > 0)
{
resultVM.Data = id;
resultVM.IsSuccess = true;
resultVM.Message = "Record added successfully!";
}
else
{
resultVM.Message = "Failed to add record!";
}
}
}
catch (Exception ex)
{
resultVM.Message = "Something went wrong!";
resultVM.Errors = ex.ToString();
Helper.LogException(ex);
}
return(Json(resultVM, JsonRequestBehavior.AllowGet));
}
//GET: Create
public ViewResult Create()
{
try
{
ResultVM result = new ResultVM();
List <string> eventNames = new List <string>();
List <EventDA> events = DataAccessServiceController.EventService.GetEvents();
foreach (var e in events)
{
eventNames.Add(e.EventName);
}
List <string> athleteNames = new List <string>();
List <AthleteDA> athletes = DataAccessServiceController.AthleteService.GetAthletes(-1);
foreach (var a in athletes)
{
athleteNames.Add(a.AthleteName);
}
athleteNames.Sort();
ViewData["eventNames"] = eventNames;
ViewData["athleteNames"] = athleteNames;
return(View("Create", result));
}
catch (Exception e)
{
throw (new Exception("Error occured in ResultsController.Create()"));
}
}
public IActionResult RecoverPassword(RecoverPasswordDTO recoverPassword)
{
_loggerManager.Info("POST RecoverPassword is requested");
if (ModelState.IsValid)
{
if (_userRepository.RecoverPassword(recoverPassword))
{
var result = new ResultVM
{
Title = sharedResource.authRecoverPasswordSuccessTitle,
Text = sharedResource.authRecoverPasswordSuccessDeccription
};
_loggerManager.Info("Password recovered successfully");
return(View("Success", result));
}
else
{
_loggerManager.Error("Password recovery failed");
ModelState.AddModelError(string.Empty, sharedResource.authRecoverPasswordNewPasswordPlaceholder);
}
}
else
{
_loggerManager.Warn("Password recovery values are invalid");
}
return(View());;
}
public ActionResult ViewResult(ResultVM result)
{
ViewBag.Students = aResultManager.GetAllStudents();
//ViewBag.RegNo ="Value ta asbe 11 theke....Kora ase";
//TempData["result"] = result;
return(RedirectToAction("GeneratePdf", "Result"));
//return View();
}
public ActionResult SearchCards(SearchVM vm)
{
var searchDescription = !string.IsNullOrWhiteSpace(vm.DescriptionContains);
var searchType = !string.IsNullOrWhiteSpace(vm.TypeContains);
var limitColorIdentities = vm.ColorIdentities != null && vm.ColorIdentities.Count() > 0;
using (var context = new Context())
{
var cards = new List <CardVM>();
var collection = _getCollection(context);
if (searchDescription)
{
var resultCards = collection.Cards
.Where(cc => cc.Card.Text != null && cc.Card.Text.Contains(vm.DescriptionContains))
.Select(c => new CardVM
{
Name = c.Card.Name,
Set = c.Card.Set.Name,
ManaCost = c.Card.ManaCost,
ConvertedManaCost = _getConvertedManacost(c.Card.ManaCost),
Type = c.Card.Type,
Text = c.Card.Text,
Amount = c.Amount
})
.Where(c => !cards.Contains(c));
cards.AddRange(resultCards);
}
if (searchType)
{
var resultCards = collection.Cards
.Where(cc => cc.Card.Type.Contains(vm.TypeContains))
.Select(c => new CardVM
{
Name = c.Card.Name,
Set = c.Card.Set.Name,
ManaCost = c.Card.ManaCost,
ConvertedManaCost = _getConvertedManacost(c.Card.ManaCost),
Type = c.Card.Type,
Text = c.Card.Text,
Amount = c.Amount
})
.Where(c => !cards.Contains(c));
cards.AddRange(resultCards);
}
var model = new ResultVM
{
Cards = cards.OrderBy(c => c.Set).OrderBy(c => c.ConvertedManaCost),
CardCount = cards.Count
};
return(View("SearchResult", model));
}
}
public async Task <IActionResult> Create([FromBody] RegisterVM model)
{
// logic could be moved into a service
if (ModelState.IsValid)
{
IdentityResult result;
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
_resultVM = new ResultVM
{
Status = Status.Error,
Message = "Invalid data",
Data = "User already exists"
};
return(Ok(_resultVM));
}
user = new IdentityUser
{
Id = Guid.NewGuid().ToString(),
UserName = model.UserName,
Email = model.Email
};
result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Admin");
_resultVM = new ResultVM
{
Status = Status.Success,
Message = "User Created",
Data = user
};
return(Ok(_resultVM));
}
return(BadRequest(new ResultVM
{
Status = Status.Error,
Message = "An Error Occured",
Data = string.Join("", result.Errors.Select(x => x.Description))
}));
}
return(BadRequest(new ResultVM
{
Status = Status.Error,
Message = "An Error Occured"
}));
}
public ResultVM GetTotal(HttpContext context)
{
var vm = new ResultVM();
vm.hasError = false;
vm.data = "累计生产时间:100H,累计产量3600公斤";
return(vm);
}
public async Task <ResultVM> Login([FromBody] LoginVM model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var result = new ResultVM();
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
// Rule #1
if (!await _signInManager.CanSignInAsync(user))
{
result.Status = Status.Error;
result.Data = "<li>Email confirmation required</li>";
return(result);
}
var signInResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, true,
lockoutOnFailure : false);
result.Status = signInResult == SignInResult.Success ? Status.Success : Status.Error;
result.Message = signInResult == SignInResult.Success ? $"Welcome {user.UserName}" : "Invalid login";
result.Data = signInResult == SignInResult.Success ? (object)model : $"<li>Invalid login attempt - {signInResult}</li>";
return(result);
}
result.Status = Status.Error;
result.Data = $"<li>Invalid Username or Password</li>";
return(result);
}
return(new ResultVM
{
Status = Status.Error,
Message = "Invalid data",
Data = "<li>Invalid Username or Password</li>"
});
}
var errors = ModelState.Keys.Select(e => "<li>" + e + "</li>");
return(new ResultVM
{
Status = Status.Error,
Message = "Invalid data",
Data = string.Join("", errors)
});
}
public ResultVM GetPowerData(HttpContext context)
{
var vm = new ResultVM();
vm.hasError = false;
var Line = context.Request.Params["Line"];
var list = KanbanEnergyLoader.GetPowerData(Line);
vm.data = JsonSerializeHelper.SerializeObject(list);
return(vm);
}
// GET: /Messages/ResultPage
public ActionResult ResultPage()
{
ResultVM resultVM = new ResultVM();
resultVM.ErrorOccurred = false;
resultVM.Title = "Redirect";
resultVM.Message = "Click continue to return to the Member Page";
resultVM.RedirectViewName = "Member";
resultVM.RedirectControllerName = "Home";
return(View(resultVM));
}
public ResultVM GetEnergyAlarm(HttpContext context)
{
var vm = new ResultVM();
vm.hasError = false;
var Line = context.Request.Params["Line"];
var msg = KanbanEnergyLoader.GetEnergyAlarm(Line);
var total = KanbanProcessLoader.GetTotal(Line);
vm.data = total + msg;
return(vm);
}
public void TestResultDAtoVM()
{
ResultDA source = new ResultDA {
ResultID = 1, AthleteID = 1, Athlete = new AthleteDA(), EventID = 1, Event = new EventDA(), DateOfResult = DateTime.Now, Result = 11.3, IsDeleted = false
};
ResultVM dest = new ResultVM();
Assert.AreNotEqual(11.3, dest.Result);
Mapper.Map(source, dest);
Assert.AreEqual(11.3, dest.Result);
}
public async Task <ResultVM> LogOutUser(string userId, string userToken)
{
try
{
// This code is for whenever I make a mistake can't sign out the user.
//await _signInManager.SignOutAsync();
//ResultVM userV = new ResultVM
//{
// Success = "User was successfully signed out."
//};
//return userV;
if (string.IsNullOrWhiteSpace(userId) || string.IsNullOrWhiteSpace(userToken))
{
throw new Exception("Something went wrong. Please try again.");
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
throw new Exception("User could not be found. Please try again or contact administration if this problem persists.");
}
var result = await _userManager.VerifyUserTokenAsync(user, "Default", "authentication-backend", userToken);
if (true)
{
await _signInManager.SignOutAsync();
ResultVM userVM = new ResultVM
{
Success = "User was successfully signed out."
};
return(userVM);
}
else
{
throw new Exception("User could not be verified. Is it really you?");
}
}
catch (Exception ex)
{
ResultVM userVM = new ResultVM
{
Failed = ex.Message
};
return(userVM);
}
}
public string SaveResult(ResultVM student)
{
int rowAffected = aResultGateway.SaveResult(student);
if (rowAffected > 0)
{
return("Save successful");
}
else
{
return("Save failed");
}
}
public ResultVM GetL03MF(HttpContext context)
{
var vm = new ResultVM();
vm.hasError = false;
var list = new List <VM_PROCESS>();
list = KanbanProcessLoader.GetMFGL("L03", "MF");
vm.data = JsonSerializeHelper.SerializeObject(list);
return(vm);
}
public async Task <GraphVM> GetGraphDataAsync(ResultVM resultVM)
{
await SetupDataAsync(resultVM.StartDate, resultVM.EndDate, resultVM.CandleDuration, resultVM.ActiveInstrument);
var instrumentID = Data[0].InstrumentID;
GetMADifference(resultVM.MovingAverage1, resultVM.MovingAverage2);
GetIntersections(resultVM.MovingAverage2);
var results = GetAllTransactionData(instrumentID);
return(results);
}
public async Task <ResultVM> VerifyAuthenticator([FromBody] VefiryAuthenticatorVM verifyAuthenticator)
{
var user = await _userManager.GetUserAsync(User);
if (!ModelState.IsValid)
{
var errors = GetErrors(ModelState).Select(e => "<li>" + e + "</li>");
return(new ResultVM
{
Status = Status.Error,
Message = "Invalid data",
Data = string.Join("", errors)
});
}
var verificationCode = verifyAuthenticator.VerificationCode.Replace(" ", string.Empty).Replace("-", string.Empty);
var is2FaTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
if (!is2FaTokenValid)
{
return(new ResultVM
{
Status = Status.Error,
Message = "Invalid data",
Data = "<li>Verification code is invalid.</li>"
});
}
await _userManager.SetTwoFactorEnabledAsync(user, true);
var result = new ResultVM
{
Status = Status.Success,
Message = "Your authenticator app has been verified",
};
if (await _userManager.CountRecoveryCodesAsync(user) != 0)
{
return(result);
}
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
result.Data = new { recoveryCodes };
return(result);
}
public async Task <ResultVM> SaveRepsUnilateral(UnilateralExercisesHistoryVM reps)
{
try
{
ResultVM resultVM = await HttpMethods <UnilateralExercisesHistoryVM> .PostAsync(Client, reps, "/SaveRepsUnilateral");
return(resultVM);
}
catch (Exception ex)
{
return(new ResultVM {
Message = ex.Message,
Status = Status.Error
});
}
}
// GET: surveys/results
public ActionResult Results()
{
IEnumerable <Answer> answers = this._answersRepository.All();
List <string> uniqueAnswers = answers
.Select(answer => answer.CallSid)
.Distinct().ToList();
var vm = new ResultVM
{
Calls = uniqueAnswers,
Answers = answers,
SurveyName = answers.FirstOrDefault()?.Question.Survey.Title
};
return(this.View(vm));
}
public ResultVM GetResult(int turnNumber, int turnOrder)
{
var result = new ResultVM();
result.TurnNumber = mgr.CurrentGame.CurrentTurnNumber;
var playerResults =
mgr.CurrentGame.Combatants.FirstOrDefault(x=>x.TurnOrder == turnOrder).Results.FirstOrDefault(x => x.TurnNumber == turnNumber && x.TurnOrder == turnOrder );
var enemyResults =
mgr.CurrentGame.Combatants.FirstOrDefault(x => x.TurnOrder != turnOrder)
.Results.FirstOrDefault(x => x.TurnNumber == turnNumber && x.TurnOrder == turnOrder);
if (playerResults != null)
{
if (playerResults.Event != null)
{
result.Event = new EventVM
{
Name = playerResults.Event.Name,
GraphicName =
playerResults.Event.GraphicName == null
? ""
: "/Graphics/" + playerResults.Event.GraphicName,
RequiredStat = playerResults.Event.RequiredStat.ToString(),
TargetNumber = playerResults.Event.TargetNumber,
Type = playerResults.Event.Type,
StatReward = playerResults.Event.StatReward,
Description = playerResults.Event.Description
};
if (playerResults.Event.ItemReward != null)
result.ItemReward = new ItemVM(playerResults.Event.ItemReward);
}
result.PlayerName = playerResults.Combatant.Name;
result.Rolls = playerResults.Rolls.ConvertStringToNumberList();
result.RollsSum = playerResults.RollsSum;
result.DieResultGraphics = result.Rolls.GetDieGraphics();
result.StatReward = playerResults.StatReward;
}
if (enemyResults == null) return result;
result.IsAttack = true;
result.EnemyRolls = enemyResults.Rolls.ConvertStringToNumberList();
result.EnemyRollsSum = enemyResults.RollsSum;
result.DieResultEnemyGraphics = result.EnemyRolls.GetDieGraphics();
result.Healthloss = enemyResults.Healthloss;
return result;
}
