public async Task <string> UpdateScenarioAsync([FromBody] ScenarioViewModel request, int projectId)
{
var response = new ListModelResponse <ScenarioViewModel>();
var scenariosDataModel = false;
try
{
scenariosDataModel = await _scenarioRepository.UpdateScenario(request.ToEntity(), projectId);
if (scenariosDataModel)
{
// response.Message = String.Format("Record Updated Successfully");
response.Message = Messages.SuccessMsg;
}
else
{
// response.Message = String.Format("Record Updation failed");
response.Message = Messages.FailMsg;
}
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.Message;
}
return(response.Message);
}
public MainWindow ResolveMainWindow(string[] args)
{
MainWindow client = new MainWindow();
ScenarioFile dairyScenario = new ScenarioFile();
ScenarioFile fieldScenario = new ScenarioFile();
ScenarioDefaults defaults = new ScenarioDefaults();
//string pathToWeatherDatabase = Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "Assets", "Database", "Weather");
string pathToWeatherDatabase = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "DairyCropSyst", "Database", "Weather");
WeatherGrabber grabber = new WeatherGrabber(pathToWeatherDatabase);
ScenarioReader reader =
new ScenarioReader(dairyScenario, fieldScenario);
ScenarioWriter writer =
new ScenarioWriter(dairyScenario, fieldScenario, defaults, grabber);
ScenarioViewModel context = new ScenarioViewModel(reader, writer);
client.DataContext = context;
if (args.Length == 1)
{
tryOpenFile(args[0], context);
}
return(client);
}
public ActionResult Create()
{
var viewModel = new ScenarioViewModel();
viewModel.IsActive = true;
return(View(viewModel));
}
private static void FillExecutionResult(ScenarioViewModel scenario)
{
if (_executionResults.TryGetValue(scenario.Id, out var executionResult))
{
scenario.FillExecutionResults(executionResult);
}
}
public async Task <string> DeleteScenAsync([FromBody] ScenarioViewModel request)
{
var response = new ListModelResponse <ScenarioViewModel>();
var scenariosDataModel = false;
try
{
scenariosDataModel = await _scenarioRepository.DeleteScenario(request.ToEntity());
if (scenariosDataModel)
{
response.Message = Messages.DeletionSuccessMsg;
}
else
{
response.Message = Messages.DeletionFailMsg;
}
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.Message;
}
return(response.Message);
}
public async Task <string> CreateScenarioAsync([FromBody] ScenarioViewModel request)
{
// HttpRequest res = null;
var response = new ListModelResponse <ScenarioViewModel>();
var scenarioDataModel = 0;
try
{
//Logic to add new scenario comes here
var maxscenId = await _scenarioRepository.GetMaxScenarioId(request.ProjectId.Value);
request.MainScenarioId = Convert.ToString(Convert.ToInt32(maxscenId.FirstOrDefault()) + 1); //ends here
scenarioDataModel = await _scenarioRepository.CreateScenario(request.ToEntity());
if (scenarioDataModel > 0)
{
// response.Message = String.Format("Created User Successfully");
response.Message = Messages.CreateSuccessMsg;
}
else
{
//response.Message = String.Format("Create User failed");
response.Message = Messages.CreateFailMsg;
}
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.Message;
}
return(response.Message);
}
public void ToXmlTest()
{
ScenarioViewModel target = new ScenarioViewModel(); // TODO: Initialize to an appropriate value
XElement expected = null; // TODO: Initialize to an appropriate value
XElement actual;
}
public static ScenarioEntity ToScenario(ScenarioViewModel model)
{
return(new ScenarioEntity
{
Id = model.Id,
Name = model.Name
});
}
public async Task <IActionResult> Put(ScenarioViewModel scenarioModel)
{
var scenario = _mapper.Map <ScenarioViewModel, Scenario>(scenarioModel);
_context.Entry(scenario).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
private bool tryOpenFile(string filePath, ScenarioViewModel context)
{
FileInfo file = new FileInfo(filePath);
if (file.Exists && file.Extension == ".NIFA_dairy_scenario")
{
context.GetScenario(filePath);
}
return(true);
}
public Scenario(int? scenarioID, int? scenarioGroupID)
{
InitializeComponent();
ScenarioViewModel = new ScenarioViewModel(new DataAccess.ScenarioRepository(), typeof(AppSecurity.Scenario).Name, "Scenario");
ScenarioViewModel.SetUp(scenarioID, scenarioGroupID);
this.DataContext = ScenarioViewModel;
Model.Initialize();
Model.GetDataAsync();
Model.FinishedAsyncJob += Model_FinishedAsyncJob;
}
public MainWindow()
{
InitializeComponent();
//register for unhandled exceptions
Application.Current.DispatcherUnhandledException += new System.Windows.Threading.DispatcherUnhandledExceptionEventHandler(Current_DispatcherUnhandledException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
svm = new ScenarioViewModel();
DataContext = svm;
svm.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(svm_PropertyChanged);
}
public InternedStringsViewModel(ScenarioViewModel vm)
{
this.Scenario = vm;
this.FilteredStrings = new ObservableCollection <FilteredStringVm>();
foreach (var kv in vm.InternedStrings)
{
this.FilteredStrings.Add(new FilteredStringVm(kv.Key, kv.Value));
}
}
public async Task <IActionResult> Post(ScenarioViewModel scenarioModel)
{
var scenario = _mapper.Map <ScenarioViewModel, Scenario>(scenarioModel);
_context.Add(scenario);
await _context.SaveChangesAsync();
new AutomateScenarioGrade(_context).AddPotentialTemplatesToNewScenario(scenario.ID);
return(Ok(scenario.ID));
}
public ActionResult Edit(ScenarioViewModel viewModel)
{
var request = viewModel.MapTo <SaveScenarioRequest>();
var response = _scenarioService.SaveScenario(request);
TempData["IsSuccess"] = response.IsSuccess;
TempData["Message"] = response.Message;
if (response.IsSuccess)
{
return(RedirectToAction("Index"));
}
return(View("Edit", viewModel));
}
public async Task <IActionResult> Edit(ScenarioViewModel model)
{
if (!_userHelperService.HasSelectedGroup(User))
{
return(RedirectToAction(nameof(GroupsController.Index), "Groups"));
}
var selectedGroup = _userHelperService.GetSelectedGroup(User);
ViewBag.Chains = await _context.Chains
.Where(x => x.IdGroup == selectedGroup.Key)
.ToDictionaryAsync(x => x.Id, x => x.Name);
return(View("Edit", model));
}
void ObjectsItemEndEdit(IEditableObject sender)
{
ScenarioViewModel UIObject = sender as ScenarioViewModel;
try
{
if (UIObject.Variable != null)
{
ScenariosDataAccess.UpdateScenario(UIObject.GetDataObject());
}
}
catch (Exception ex)
{
log.Error(ex.StackTrace);
}
}
public async Task <IActionResult> Create()
{
if (!_userHelperService.HasSelectedGroup(User))
{
return(RedirectToAction(nameof(GroupsController.Index), "Groups"));
}
ScenarioViewModel newScenario = new ScenarioViewModel()
{
IsStrictMatch = true
};
var selectedGroup = _userHelperService.GetSelectedGroup(User);
ViewBag.Chains = await _context.Chains
.Where(x => x.IdGroup == selectedGroup.Key)
.ToDictionaryAsync(x => x.Id, x => x.Name);
return(View("Edit", newScenario));
}
public void LoadScenario(string path)
{
foreach (var c in childWindows)
{
c.Close();
}
childWindows.Clear();
if (string.IsNullOrEmpty(path))
{
prefManager.StoreAppPreferences(prefs);
return;
}
var matfac = new MaterialFactory(Environment.CurrentDirectory + "/Configs");
var factory = new MapFactory(Path.GetDirectoryName(path));
var scene = factory.Load(Path.GetFileName(path));
var vm = new ScenarioViewModel(scene, prefs.DiscoveryMode);
DataCtx.LoadedScenario = vm;
DataCtx.SelectedEntry = vm.TreeRoots[0];
loadedMap = path;
this.Title = $"OpenH2 Scenario Explorer - {Path.GetFileName(path)} {(prefs.DiscoveryMode ? "[Discovery Mode]" : "")}";
prefs.LastBrowseLocation = Path.GetDirectoryName(path);
var list = prefs.RecentFiles.ToList();
list.Insert(0, path);
prefs.RecentFiles = list.Take(5).Distinct().ToArray();
prefManager.StoreAppPreferences(prefs);
}
public async Task <IActionResult> Edit(Guid?idScenario)
{
if (idScenario == null)
{
return(NotFound());
}
var scenario = await _context.Scenarios.FirstOrDefaultAsync(x => x.Id == idScenario);
var model = new ScenarioViewModel()
{
IdScenario = idScenario,
Name = scenario.Name,
Action = scenario.Action,
IdChain = scenario.IdChain,
IdChain2 = scenario.IdChain2,
IdErrorMessage = scenario.IdErrorMessage,
IdMessage = scenario.IdMessage,
IsStrictMatch = scenario.IsStrictMatch,
InputMessage = scenario.InputMessage
};
if (scenario.IdMessage.HasValue)
{
var message = await _context.Messages
.Include(x => x.Files)
.FirstOrDefaultAsync(x => x.Id == scenario.IdMessage.Value);
if (message != null)
{
uint idx = 0;
model.Message.IsImageFirst = message.IsImageFirst;
model.Message.Message = message.Text;
var keyboard = string.IsNullOrWhiteSpace(message.Keyboard) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <VkNet.Model.Keyboard.MessageKeyboard>(message.Keyboard);
if (keyboard != null)
{
model.Message.Keyboard = new List <List <ViewModels.Shared.MessageButton> >();
byte currentRowIdx = 0;
foreach (var currentRow in keyboard.Buttons)
{
byte colIdx = 0;
model.Message.Keyboard.Add(currentRow.Select(x => new ViewModels.Shared.MessageButton()
{
ButtonColor = x.Color.ToString(),
Column = colIdx++,
CanDelete = colIdx == currentRow.Count(),
Row = currentRowIdx,
Text = x.Action.Label
}).ToList());
currentRowIdx++;
}
}
model.Message.Files = message.Files.Select(x => new ViewModels.Shared.FileModel()
{
Id = x.IdFile,
Name = _context.Files.Where(y => y.Id == x.IdFile).Select(y => y.Name).FirstOrDefault(),
Index = idx++,
PropertiesPrefix = nameof(ScenarioViewModel.Message)
}).ToList();
}
}
if (scenario.IdErrorMessage.HasValue)
{
var message = await _context.Messages
.Include(x => x.Files)
.FirstOrDefaultAsync(x => x.Id == scenario.IdErrorMessage.Value);
if (message != null)
{
uint idx = 0;
model.ErrorMessage.Message = message.Text;
model.ErrorMessage.IsImageFirst = message.IsImageFirst;
var keyboard = string.IsNullOrWhiteSpace(message.Keyboard) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <VkNet.Model.Keyboard.MessageKeyboard>(message.Keyboard);
if (keyboard != null)
{
model.ErrorMessage.Keyboard = new List <List <ViewModels.Shared.MessageButton> >();
byte currentRowIdx = 0;
foreach (var currentRow in keyboard.Buttons)
{
byte colIdx = 0;
model.ErrorMessage.Keyboard.Add(currentRow.Select(x => new ViewModels.Shared.MessageButton()
{
ButtonColor = x.Color.ToString(),
Column = colIdx++,
CanDelete = colIdx == currentRow.Count(),
Row = currentRowIdx,
Text = x.Action.Label
}).ToList());
currentRowIdx++;
}
}
model.ErrorMessage.Files = message.Files.Select(x => new ViewModels.Shared.FileModel()
{
Id = x.IdFile,
Name = _context.Files.FirstOrDefault(y => y.Id == x.IdFile)?.Name,
Index = idx++,
PropertiesPrefix = nameof(ScenarioViewModel.ErrorMessage)
}).ToList();
}
}
var selectedGroup = _userHelperService.GetSelectedGroup(User);
ViewBag.Chains = await _context.Chains
.Where(x => x.IdGroup == selectedGroup.Key)
.ToDictionaryAsync(x => x.Id, x => x.Name);
return(View("Edit", model));
}
public async Task <IActionResult> Save(ScenarioViewModel model)
{
if (!ModelState.IsValid)
{
return(await Edit(model));
}
var groupInfo = _userHelperService.GetSelectedGroup(User);
Scenarios scenario = null;
if (model.IdScenario.HasValue)
{
scenario = await _context.Scenarios.FirstOrDefaultAsync(x => x.Id == model.IdScenario.Value);
}
if (scenario == null)
{
scenario = new Scenarios
{
IsEnabled = true,
IdGroup = groupInfo.Key
};
await _context.Scenarios.AddAsync(scenario);
}
scenario.Action = model.Action;
switch (model.Action)
{
case Models.Database.Common.ScenarioActions.Message:
{
scenario.IdChain = null;
scenario.IdChain2 = null;
break;
}
case Models.Database.Common.ScenarioActions.AddToChain:
{
scenario.IdChain = model.IdChain;
scenario.IdChain2 = null;
break;
}
case Models.Database.Common.ScenarioActions.RemoveFromChain:
{
scenario.IdChain = null;
scenario.IdChain2 = model.IdChain2;
break;
}
case Models.Database.Common.ScenarioActions.ChangeChain:
{
scenario.IdChain = model.IdChain;
scenario.IdChain2 = model.IdChain2;
break;
}
}
scenario.InputMessage = model.InputMessage;
scenario.Name = model.Name;
scenario.IsStrictMatch = model.IsStrictMatch;
if (model.Message?.HasMessage ?? false)
{
if (model.IdMessage.HasValue)
{
var message = await _context.Messages
.Include(x => x.Files)
.FirstOrDefaultAsync(x => x.Id == model.IdMessage.Value);
message.Text = model.Message.Message;
message.IsImageFirst = model.Message.IsImageFirst;
var keyboard = model.Message.GetVkKeyboard();
message.Keyboard = keyboard == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(keyboard);
if (model.Message.Files != null && model.Message.Files.Any())
{
IEnumerable <Guid> newIdFiles = model.Message.Files.Select(x => x.Id);
if (message.Files != null && message.Files.Any())
{
newIdFiles = newIdFiles.Except(message.Files.Select(x => x.IdFile));
}
DbHelper.AddFilesInMessage(_context, model.IdMessage.Value, newIdFiles);
}
}
else
{
var message = await DbHelper.AddMessage(_context, groupInfo.Key, model.Message.Message, model.Message.GetVkKeyboard(), model.Message.IsImageFirst, model.Message.Files.Select(x => x.Id));
scenario.IdMessage = message.Id;
}
}
else if (scenario.Message != null)
{
scenario.IdMessage = null;
await DbHelper.RemoveMessage(_context, scenario.IdMessage.Value);
}
if (model.ErrorMessage?.HasMessage ?? false)
{
if (model.Action == Models.Database.Common.ScenarioActions.Message)
{
await DbHelper.RemoveMessage(_context, scenario.IdErrorMessage.Value);
scenario.IdErrorMessage = null;
}
else if (model.IdErrorMessage.HasValue)
{
var message = await _context.Messages
.Include(x => x.Files)
.FirstOrDefaultAsync(x => x.Id == model.IdErrorMessage.Value);
message.Text = model.ErrorMessage.Message;
message.IsImageFirst = model.ErrorMessage.IsImageFirst;
var keyboard = model.ErrorMessage.GetVkKeyboard();
message.Keyboard = keyboard == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(keyboard);
if (model.Message.Files != null && model.Message.Files.Any())
{
IEnumerable <Guid> newIdFiles = model.Message.Files.Select(x => x.Id);
if (message.Files != null && message.Files.Any())
{
newIdFiles = newIdFiles.Except(message.Files.Select(x => x.IdFile));
}
DbHelper.AddFilesInMessage(_context, message.Id, newIdFiles);
}
}
else
{
var message = await DbHelper.AddMessage(_context, groupInfo.Key, model.ErrorMessage.Message, model.ErrorMessage.GetVkKeyboard(), model.ErrorMessage.IsImageFirst, model.ErrorMessage.Files.Select(x => x.Id));
scenario.IdErrorMessage = message.Id;
}
}
else if (scenario.ErrorMessage != null)
{
scenario.IdErrorMessage = null;
await DbHelper.RemoveMessage(_context, scenario.IdErrorMessage.Value);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public void Bind(ScenarioViewModel vm)
{
this.DataContext = new InternedStringsViewModel(vm);
}
