private AnalysisViewModel GetTestViewModel(string url)
{
string truncated_url = url;
if (truncated_url.StartsWith("https://"))
{
truncated_url = truncated_url.Substring(8);
}
if (truncated_url.StartsWith("http://"))
{
truncated_url = truncated_url.Substring(7);
}
if (truncated_url.StartsWith("www."))
{
truncated_url = truncated_url.Substring(4);
}
if (truncated_url.Contains("/"))
{
truncated_url = truncated_url.Substring(0, truncated_url.IndexOf("/"));
}
AnalysisViewModel model = new AnalysisViewModel()
{
Url = truncated_url
};
return(model);
}
public IActionResult Mentions(QueryUserViewModel queryUserViewModel)
{
if (ModelState.IsValid)
{
var model = new AnalysisViewModel
{
Username = queryUserViewModel.TwitterHandle
};
var tweets = _twitterService.GetTweetsAsync(queryUserViewModel.TwitterHandle).Result;
try
{
model.AnalysisResults = _textAnalysis.AnalyzeTweets(tweets);
}
catch (Exception ex)
{
throw ex;
}
return(View(model));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> Create(Int32?patientId, AnalysisViewModel model)
{
if (patientId == null)
{
return(this.NotFound());
}
var patient = await this._context.Patients
.SingleOrDefaultAsync(x => x.Id == patientId);
if (patient == null)
{
return(this.NotFound());
}
if (this.ModelState.IsValid)
{
var analysis = new Analysis
{
PatientId = patient.Id,
LabId = model.LabId,
Type = model.Type,
Date = model.Date,
Status = model.Status
};
this._context.Add(analysis);
await this._context.SaveChangesAsync();
return(this.RedirectToAction("Index", new { patientId = patient.Id }));
}
this.ViewBag.Patient = patient;
return(this.View(model));
}
public AnalysisPage()
{
InitializeComponent();
InitText();
C1Animation loadAnimation = new C1Animation();
loadAnimation.Duration = new TimeSpan(1000 * 10000);
loadAnimation.Easing = Xamarin.Forms.Easing.CubicInOut;
flexPie.LoadAnimation = loadAnimation;
flexPie.CustomPalette = CustomPalette;
flexChart.LoadAnimation = loadAnimation;
flexChart.CustomPalette = CustomPalette;
filterPage = new AnalysisFilterPage(this);
model = new AnalysisViewModel();
model.PropertyChanged += OnVMPropertyChanged;
initialized = false;
switch (Device.RuntimePlatform)
{
case Device.iOS:
{
ToolbarItems.Remove(btnMonthData);
ToolbarItems.Remove(btn3MonthsData);
ToolbarItems.Remove(btn6MonthsData);
ToolbarItems.Remove(btnYearData);
ToolbarItems.Remove(btn2YearsData);
this.ToolbarItems.Add(new ToolbarItem(AppResources.ToolbarFilterText, "", () => { OnFilterClick(); }, 0, 0));
}
break;
}
}
public void ConstructorTest_Visibility()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
Assert.IsTrue(main.SelectedDistribution.Instance is NormalDistribution);
AnalysisViewModel target = main.Analysis;
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.EqualTo);
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.Outside);
Assert.IsTrue(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.GreaterThan);
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.Between);
Assert.IsTrue(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.LessThan);
Assert.IsFalse(target.LeftValueVisible);
}
public async Task <IActionResult> Edit(Int32?id, AnalysisViewModel model)
{
if (id == null)
{
return(NotFound());
}
var analysis = await this._context.Analyses
.SingleOrDefaultAsync(a => a.Id == id);
if (analysis == null)
{
return(this.NotFound());
}
if (this.ModelState.IsValid)
{
analysis.LabId = model.LabId;
analysis.Type = model.Type;
analysis.Status = model.Status;
analysis.Date = model.Date;
await this._context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new { patientId = analysis.PatientId }));
}
ViewData["LabId"] = new SelectList(_context.Labs, "Id", "Name", analysis.LabId);
this.ViewBag.Analysis = analysis;
return(View(model));
}
public async Task <IActionResult> Edit(Int32?id, AnalysisViewModel model)
{
if (id == null)
{
return(this.NotFound());
}
var analysis = await this._context.Analyses.SingleOrDefaultAsync(m => m.Id == id);
if (analysis == null)
{
return(this.NotFound());
}
if (this.ModelState.IsValid)
{
analysis.LabId = model.LabId;
analysis.Type = model.Type;
analysis.Date = model.Date;
analysis.Status = model.Status;
await this._context.SaveChangesAsync();
return(this.RedirectToAction("Index", new { patientId = analysis.PatientId }));
}
return(this.View(model));
}
// GET: Analyses/Edit/5
public async Task <IActionResult> Edit(Int32?id)
{
if (id == null)
{
return(this.NotFound());
}
var analysis = await _context.Analyses.SingleOrDefaultAsync(m => m.Id == id);
if (analysis == null)
{
return(NotFound());
}
var model = new AnalysisViewModel
{
LabId = analysis.LabId,
Type = analysis.Type,
Date = analysis.Date,
Status = analysis.Status
};
ViewData["LabId"] = new SelectList(_context.Labs, "Id", "Name", analysis.LabId);
this.ViewBag.Analysis = analysis;
return(View(model));
}
public SaveWindow(AnalysisViewModel viewModel)
{
InitializeComponent();
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
DataContext = ViewModel = viewModel;
Filename = InitialDir;
}
public static void Export(this AnalysisViewModel viewModel, ExportFileType type, string path)
{
switch (type.Title)
{
case "Analysis":
viewModel.ExportSimulation(path, type.Extension);
break;
case "Graph":
viewModel.ExportPlot(path, type.Extension);
break;
case "Macrocycle":
viewModel.ExportCycle(path);
break;
case "Molecule":
viewModel.ExportMolecule(path);
break;
case "XYData":
viewModel.ExportData(path, type.Extension);
break;
}
}
public void Create()
{
//Arrange
var analysisViewModel = new AnalysisViewModel
{
Hemoglobin = 150,
Hematocrit = 0.35,
PlateletCount = 150000,
Alt = 5,
Ast = 20,
Cpk = 50,
Proteins = 70,
Sodium = 150,
Potassium = 4,
Chloride = 100
};
//Act
var analysisId = _analysisService.Create(analysisViewModel);
var analysis = _dataContext.Analyses.SingleOrDefault(a => a.Id == analysisId);
//Assert
Assert.That(analysisId, Is.Not.Zero);
Assert.That(analysis, Is.Not.Null);
}
public ActionResult CreateOrEdit(int?id)
{
try
{
int userId = Convert.ToInt32(HttpContext.User.Identity.Name);
AnalysisViewModel analysisViewModel = new AnalysisViewModel();
if (id.HasValue) //quando o id tem valor é uma edição, pois ele vai na serviço procurar a analise para retornar a view
{
Analysis analysis = services.AnalysisService.GetById(id.Value);
if (analysis != null)
{
analysisViewModel = new AnalysisViewModel().ToViewModel(analysis);
analysisViewModel.Lots = services.LotService.GetAllByClient(userId).OrderBy(p => p.Code).ToSelectList(t => t.Code, x => x.Id.ToString(), analysis.LotId.ToString());
analysisViewModel.Laboratories = services.LaboratoryService.GetAllByClient(userId).OrderBy(p => p.Name).ToSelectList(t => t.Name, x => x.Id.ToString(), analysis.LaboratoryId.ToString());
return(View(analysisViewModel));
}
else
{
return(Json(new { Msg = "Análise não encontrada", Erro = true }, JsonRequestBehavior.AllowGet));
}
}
analysisViewModel.Lots = services.LotService.GetAllByClient(userId).OrderBy(p => p.Code).ToSelectList(t => t.Code, x => x.Id.ToString(), "Lote", "");
analysisViewModel.Laboratories = services.LaboratoryService.GetAllByClient(userId).OrderBy(p => p.Name).ToSelectList(t => t.Name, x => x.Id.ToString(), "Laboratório", "");
return(View(analysisViewModel));
}
catch (Exception e)
{
return(Json(new { Msg = e.Message, Erro = false }));
}
}
public AnalysisGameViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
: base(gameSettings, questsManager, dialogService)
{
AnalysisViewModel = new AnalysisViewModel();
AnalysisViewModel.BackToGameRequested += (s, e) => OnAnalysisBackToGameRequested();
AnalysisViewModel.BranchDeletionRequested += (s, e) => OnAnalysisBranchDeletionRequested();
AnalysisViewModel.PassRequested += (s, e) => OnAnalysisPassRequested();
}
public static void compute(AnalysisViewModel target, double left, string comparison, double right)
{
target.LeftValue = Double.NaN;
target.RightValue = Double.NaN;
target.LeftValue = left;
target.ComparisonIndex = target.Comparisons.IndexOf(comparison);
target.RightValue = right;
}
public void TestCtor()
{
var model = new AnalysisViewModel(_dispatcher, _viewTemplate, _analyser.Object, _analysisStorage.Object, _pluginRegistry);
model.Pages.Should().NotBeNull();
model.Pages.Should().HaveCount(1);
model.Pages.First().Should().NotBeNull();
model.Pages.First().DeletePageCommand.CanExecute(null).Should().BeFalse("because the last page may never be deleted");
}
/// <summary>
/// Save a new Analysis to the database with the data from a viewmodel.
/// </summary>
/// <param name="viewModel">Viewmodel with the new analysis data.</param>
/// <returns>Id of the newly created Analysis.</returns>
public int Create(AnalysisViewModel viewModel)
{
//Create a new Analysis from the viewmodel
var analysis = viewModel.ToNewModel();
Repository.Analyses.Add(analysis);
Save();
return(analysis.Id);
}
public void TestAddPage1()
{
var model = new AnalysisViewModel(_dispatcher, _viewTemplate, _analyser.Object, _analysisStorage.Object, _pluginRegistry);
model.Pages.Should().HaveCount(1);
model.AddPageCommand.Execute(null);
model.Pages.Should().HaveCount(2);
model.Pages.ElementAt(0).DeletePageCommand.CanExecute(null).Should().BeTrue();
model.Pages.ElementAt(1).DeletePageCommand.CanExecute(null).Should().BeTrue();
}
public AnalysisFilterPage(AnalysisPage page)
{
InitializeComponent();
analysisPage = page;
model = new AnalysisViewModel();
RegionFilter = model.Regions;
ProductFilter = model.Products;
regionFilterBackup = CloneRegionFilter(RegionFilter);
productFilterBackup = CloneProductFilter(ProductFilter);
}
public IActionResult Analysis(string url)
{
var model = GetTestViewModel(url);
var backup = new AnalysisViewModel();
var terms = backup.TermsDictionary.ContainsKey(url) ? backup.TermsDictionary.GetValueOrDefault(url).First(x => x.Key == "General") : backup.TermsDictionary.First().Value.First(x => x.Key == "General");
model.Terms = terms;
return(View(model));
}
public ActionResult Index(AnalysisViewModel viewModel)
{
if (viewModel.Tweet != null)
{
var greyTweetAnalyser = new GreyTweetAnalyser();
var analysisResult = greyTweetAnalyser.CalculateTweetPerception(viewModel.Tweet);
viewModel.AnalysisResult = analysisResult;
}
return(View(viewModel));
}
public void Update_NotFound()
{
//Arrange
var analysisViewModel = new AnalysisViewModel
{
Id = 123456
};
//Act
_analysisService.Update(analysisViewModel);
}
public void TestRemovePage1()
{
var model = new AnalysisViewModel(_dispatcher, _viewTemplate, _analyser.Object, _analysisStorage.Object);
_viewTemplate.Pages.Should().HaveCount(1);
model.AddPageCommand.Execute(null);
_viewTemplate.Pages.Should().HaveCount(2);
model.Pages.ElementAt(1).DeletePageCommand.Execute(null);
_viewTemplate.Pages.Should().HaveCount(1);
}
public AnalysisUserControl()
{
EnsureApplicationResources();
InitializeComponent();
vm = new AnalysisViewModel();
base.DataContext = vm;
vm.ActiveSheetChangeEvent += Vm_ActiveSheetChangeEvent;
vm.AutoRecountClick += Vm_AutoRecountClick;
ControlIsLoaded = true;
}
public void TestAddPage2()
{
var model = new AnalysisViewModel(_dispatcher, _viewTemplate, _analyser.Object, _analysisStorage.Object, _pluginRegistry);
_viewTemplate.Pages.Should().HaveCount(1);
model.AddPageCommand.Execute(null);
_viewTemplate.Pages.Should().HaveCount(2);
_viewTemplate.Pages.ElementAt(1).Should().BeSameAs(
model.Pages.ElementAt(1).Template
);
}
private IActionResult AnalysisDetails(string key, string subkey, string category)
{
var backup = new AnalysisViewModel();
var terms = backup.TermsDictionary.GetValueOrDefault(key).Find(x => x.Key == subkey);
var model = new AnalysisDetailsViewModel()
{
Category = category,
Terms = terms
};
return(View(model));
}
public static void ExportViewport(this AnalysisViewModel _, string path)
{
//get instance of MainWindow
var main = (MainWindow)Application.Current.MainWindow;
var viewPort = main?.Viewport3D;
//try to render current 3d representation
if (viewPort == null)
{
throw new InvalidOperationException("Viewport not found - can not render properly");
}
viewPort.Viewport.SaveBitmap(path + "_viewport.png", null, 4);
}
// GET: Client/Analysis
public ActionResult Index(int?LaboratoryId, string LotCode)
{
AnalysisViewModel analysis = new AnalysisViewModel();
if (!string.IsNullOrEmpty(LotCode))
{
analysis.LotId = services.LotService.GetByCode(LotCode).Id;
}
analysis.LaboratoryId = LaboratoryId;
return(View(analysis));
}
public ActionResult CreateOrEdit(AnalysisViewModel model)
{
if (ModelState.IsValid)
{
Analysis analysis = model.ToDomain();
Response response = services.AnalysisService.Save(analysis);
return(Json(new { Msg = response.Message, Erro = response.Error }));
}
else
{
return(Json(new { Msg = "Campos inválidos", Erro = true }));
}
}
public IActionResult Index()
{
var id = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier).Value;
var currentUser = _traderStore.GetAll().FirstOrDefault(u => u.TraderId == Guid.Parse(id));
var getAnalysis = _analysisService.GetAllAnalysis(currentUser.TraderId);
var analysis = new AnalysisViewModel
{
FormData = getAnalysis
};
return(View(analysis));
}
public async Task <ActionResult> Analysis(int userId)
{
var data = new List <AnalysicPerDay>();
data.Add(new AnalysicPerDay {
Day = 1, UserId = 1, CountLink = 1, CountBackLink = 1, CountWord = 1
});
AnalysisViewModel vm = new AnalysisViewModel
{
AnalysicPerWeeks = data
};
return(Json(new { data = data }, JsonRequestBehavior.AllowGet));
}
