/// <summary>
/// Processes the command.
/// </summary>
/// <param name="model">Model that triggered the command</param>
/// <param name="toProcess">Command to process</param>
public void ProcessCommand(CalcModel model, Command toProcess)
{
switch (toProcess)
{
case Command.Plus:
calculator.SetOperator(new AddOperator());
break;
case Command.Minus:
calculator.SetOperator(new MinusOperator());
break;
case Command.Multiply:
calculator.SetOperator(new MultiplyOperator());
break;
case Command.Divide:
calculator.SetOperator(new DivideOperator());
break;
case Command.Power:
calculator.SetOperator(new PowerOperator());
break;
}
}
public ActionResult SubmitNewCustomer(UserView uv)
{
if (ModelState.IsValid)
{
/*if (_roleprovider.UserExists(uv.UserName))
* {
* ModelState.AddModelError(string.Empty, "Username already in use");
*
* return PartialView("AddUser");
* }*/
var managerHelper = new CalcModel();
_manager.AddClient(uv.toBaseClient_Details());
string[] users = { uv.UserName };
string[] roles = { "Customer" };
// _roleprovider.AddUsersToRoles(users, roles);
managerHelper.ActionResult = "New Customer Submitted";
return(Json(managerHelper, JsonRequestBehavior.AllowGet));
}
else
{
return(PartialView("AddUser"));
}
}
public string Calculation(CalcModel model, ILogSingleton logger)
{
Logger = logger;
Calculator calc = new Calculator(logger);
return(calc.Calculation(model.Number1, model.Number2, model.Operator));
}
public ActionResult SubmitNewEmployee(UserView uv)
{
if (ModelState.IsValid)
{
// if (_roleprovider.UserExists(uv.UserName))
// {
ModelState.AddModelError(string.Empty, "Username already in use");
// return PartialView("AddUser");
// }
var managerHelper = new CalcModel();
var domainclient = uv.toBaseClient_Details();
_manager.AddClient(domainclient);
string[] users = { uv.UserName };
string[] roles = { "Employee" };
// _roleprovider.AddUsersToRoles(users, roles);
managerHelper.ActionResult = "New Employee Submitted";
return(Json(managerHelper, JsonRequestBehavior.AllowGet));
}
else
{
return(PartialView("AddUser"));
}
}
public IActionResult Subtract(CalcModel model)
{
var result = _calcService.Subtract(Int32.Parse(model.num1), Int32.Parse(model.num2));
model.result = result;
return(View(model));
}
public ActionResult Add(CalcModel model)
{
int result = 0;
switch (model.Op)
{
case Operation.Add: result = model.X + model.Y;
break;
case Operation.Diff: result = model.X - model.Y;
break;
case Operation.Multiply: result = model.X * model.Y;
break;
case Operation.Share: if (model.Y != 0)
{
result = model.X / model.Y;
}
;
break;
}
model.Result = string.Format("{4}: {0}{2}{1} = {3}\n", CalcResources.x, CalcResources.y, model.Op.DisplayName(), result, DateTime.Now);
Results.Add(model.Result);
return(View(model));
}
public async Task <string> Post([FromBody] CalcModel query)
{
GetQuery process = new GetQuery();
var result = await process.GettingQuery(query.Query);
return(result);
}
// GET: api/Calc
//public IEnumerable<string> Get()
//{
// return new string[] { "Calc1", "Calc2" };
//}
// GET: api/Calc/5
//public string Get(int id)
//{
//}
// POST: api/Calc
/// <summary>
/// Calculates the score
/// </summary>
/// <param name="calc"></param>
/// <returns></returns>
public IHttpActionResult Post([FromBody] CalcModel calc)
{
int result = PaulMoyaLIB.Calculator.Calculate(calc.str);
calc.score = result;
return(Ok(calc.score));
}
private void CalculateSavings(int savingsId)
{
List <Savings_Transactions> savingsList = BaseRepository.Context.Savings_Transactions
.Where(i => i.Savings_Id == savingsId)
.ToList();
CalcModel calcObj = new CalcModel();
foreach (var transaction in savingsList)
{
if (transaction.Type == "I")
{
calcObj.TotalIncome += transaction.Value;
}
else
{
calcObj.TotalOutcome += transaction.Value;
}
}
Models.DataBase.Savings savingsObj = BaseRepository.GetById(savingsId);
savingsObj.TotalAmount = calcObj.TotalProfit;
BaseRepository.Context.SaveChanges();
}
public PartialViewResult Exec(CalcModel model)
{
var result = double.NaN;
if (Calc.getOperNames().Contains(model.OperName))
{
result = Calc.Exec(model.OperName, model.InputData);
var operation = OperationRepository.LoadByName(model.OperName);
if (operation != null)
{
var history = new HistoryItemModel()
{
Operation = operation.Id,
Initiator = 1,
Result = result,
Args = string.Join(";", model.InputData),
CalcDate = DateTime.Now,
Time = 15
};
HistoryRepository.Save(history);
}
}
return(PartialView("ExecResult", result));
}
public IActionResult Index(CalcModel c)
{
c.Result = 0;
switch (c.Op)
{
case '+': c.Result = c.Number1 + c.Number2;
break;
case '-':
c.Result = c.Number1 - c.Number2;
break;
case '*':
c.Result = c.Number1 * c.Number2;
break;
case '/':
if (c.Number2 != 0)
{
c.Result = c.Number1 / c.Number2;
}
break;
}
c.Number2 = c.Result;
c.Number1 = 0;
return(View(c));
}
public ActionResult SubmitPicture(CarView car, HttpPostedFileBase picture)
{
if (ModelState.IsValid)
{
var managerHelper = new CalcModel();
var domainCar = car.toBaseCarDetails();
try
{
using (MemoryStream ms = new MemoryStream())
{
picture.InputStream.CopyTo(ms);
byte[] array = ms.GetBuffer();
domainCar.Pic = array;
_manager.UpdateCar(domainCar);
}
TempData["message"] = "Upload Succeded!";
return(RedirectToAction("Index"));
}
catch
{
TempData["message"] = "Upload Failed!";
return(RedirectToAction("Index"));
}
}
else
{
return(PartialView("AddCarPicture", car));
}
}
static async Task Main(string[] args)
{
var config = new ProducerConfig()
{
BootstrapServers = "localhost:9092"
};
Console.WriteLine("Escrevendo as mensagens no tópico");
using (var producer = new ProducerBuilder <Null, string>(config).Build())
{
for (int i = 0; i < 150; i++)
{
var model = new CalcModel(i);
var message = new Message <Null, string> {
Value = JsonConvert.SerializeObject(model)
};
await producer.ProduceAsync(TOPICO, message);
await producer.ProduceAsync(TOPICO2, message);
}
}
Console.WriteLine("Mensagens escritas com sucesso!");
var consumerConfig = new ConsumerConfig()
{
BootstrapServers = "localhost:9092",
GroupId = "MyGroup",
AutoOffsetReset = AutoOffsetReset.Earliest
};
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) => { e.Cancel = true; cts.Cancel(); };
try
{
using (var consumer = new ConsumerBuilder <Null, string>(consumerConfig)
.Build())
{
consumer.Subscribe(TOPICO);
while (true)
{
try
{
var cr = consumer.Consume(cts.Token);
var json = JsonConvert.SerializeObject(cr.Message.Value);
Console.WriteLine($"Message:{json}");
}
catch (OperationCanceledException)
{
consumer.Close();
Console.WriteLine("Cancelado....");
}
}
}
}
catch (Exception)
{
Console.WriteLine("Erro generico");
}
}
public CalcViewModel(ILogger <CalcViewModel> logger, CalcModel model)
{
_logger = logger;
_model = model;
AnalysisCommand = new DelegateCommand(Analysis);
CalculateCommand = new DelegateCommand(Calculate);
}
public JsonResult HelpAjax()
{
allCars = _manager.AllCars().Select(c => new CarView(c));
allmodels = guest.AllModels().Select(c => new ModelView(c));
allDeals = _manager.AllPurchases().Select(d => new PurchaseView(d));
allCustomers = _manager.AllCustomers().Select(u => new UserView(u));
allEmployees = _manager.AllEmployees().Select(u => new UserView(u));
var managerHelper = new CalcModel();
managerHelper.AllCarModels = allmodels;
managerHelper.AllDeals = allDeals;
managerHelper.AllCustomers = allCustomers;
managerHelper.AllEmployees = allEmployees;
managerHelper.AllCars = allCars;
return(Json(managerHelper, JsonRequestBehavior.AllowGet));
}
{ public static CalcModel Calculate(CalcModel calc)
{
switch (calc.Oprator)
{
case Operators.None:
return(calc);
case Operators.Plus:
calc.Result += calc.Num2;
calc.Num1 = calc.Num2;
return(calc);
case Operators.Minus:
calc.Result -= calc.Num2;
calc.Num1 = calc.Num2;
return(calc);
case Operators.Multiple:
calc.Result *= calc.Num2;
calc.Num1 = calc.Num2;
return(calc);
case Operators.Divide:
calc.Result /= calc.Num2;
calc.Num1 = calc.Num2;
return(calc);
default:
return(calc);
}
}
public ActionResult Exec()
{
var model = new CalcModel();
model.OperationList = new SelectList(Calc.getOperNames());
return(View(model));
}
public void Add(CalcModel newCalcModel)
{
var cmdText = "INSERT INTO Calc" +
" (Num1, Num2, Result, Operacao, Data)"+
"VALUES (@calcNum1, @calcNum2, @calcResult, @calcOp, @calcDate);";
using (var sqlConnection = new SqlConnection(_connectionString)) //já faz o close e dispose
using (var sqlCommand = new SqlCommand(cmdText, sqlConnection)) //já faz o close
{
sqlCommand.CommandType = CommandType.Text;
sqlCommand.Parameters
.Add("@calcNum1", SqlDbType.Decimal).Value = newCalcModel.Num1;
sqlCommand.Parameters
.Add("@calcNum2", SqlDbType.Decimal).Value = newCalcModel.Num2;
sqlCommand.Parameters
.Add("@calcResult", SqlDbType.Decimal).Value = newCalcModel.Result;
sqlCommand.Parameters
.Add("@calcOp", SqlDbType.VarChar).Value = newCalcModel.Operacao;
sqlCommand.Parameters
.Add("@calcDate", SqlDbType.DateTime2).Value = newCalcModel.Data;
sqlConnection.Open();
var resultScalar = sqlCommand.ExecuteScalar();
}
}
public ActionResult MultOption(CalcModel Model)
{
var result = new CalcResultModel();
CalcService Service = new CalcService();
result.result = Service.Multiply(Model);
return(Ok(result));
}
public IActionResult Multiply(CalcModel model)
{
Thread.Sleep(3000);
var result = _calcService.Multiply(Int32.Parse(model.num1), Int32.Parse(model.num2));
model.result = result;
return(View(model));
}
public IActionResult ModelBindingInSeparateModel(CalcModel model)
{
ViewBag.Result = ModelState.IsValid
? model.Calc()
: "Invalid input";
return(View("Result"));
}
public void Setup()
{
model = new CalcModel();
lastDisplayUpdate = "";
timesDisplayUpdated = 0;
lastCommand = null;
timesCommandUpdate = 0;
}
public MainWindowViewModel()
{
calc = new CalcModel();
result = String.Empty;
openBracketCount = 0;
closeBracketCount = 0;
ButtonCommand = new Command(s => InputMethod(s as string));
}
public ActionResult SubOption(CalcModel Model)
{
var result = new CalcResultModel();
CalcService Service = new CalcService();
result.result = Service.Subtract(Model);
return(Ok(result));
}
public ActionResult DivOption(CalcModel Model)
{
var result = new CalcResultModel();
CalcService Service = new CalcService();
result.result = Service.Divide(Model);
return(Ok(result));
}
public ActionResult Index(string button)
{
//CalcModel model = (CalcModel)Session["model"];
CalcModel model = stateManager.load("model");
ProcessInput(button, model);
return(View("Index", model));
}
public ActionResult Index()
{
var model = new CalcModel()
{
Operations = Calc.GetOperationNames()
};
return(View(model));
}
public ActionResult Index()
{
var model = new CalcModel();
stateManager.save("model", model);
//Session["model"] = model;
return(View("Index", model));
}
public IActionResult CountFour(CalcModel calcModel)
{
ViewBag.input1 = calcModel.value1;
ViewBag.input2 = calcModel.value2;
ViewBag.operation = calcModel.operation;
ViewBag.result = calcModel.Calculate();
return(View("Result"));
}
public IActionResult ModelBindingSeparateModel(CalcModel calcModel)
{
Dictionary <string, string> result = this.calculate(calcModel._firstInt, calcModel._action, calcModel._secondInt);
string data = $"{calcModel._firstInt} {result["action"]} {calcModel._secondInt} = {result["answer"]}";
ViewData["result"] = data;
return(View("Result"));
}
