public ActionResult Index(ConditionViewModel <Advertisement, AdvertisementViewModel> input)
{
Expression <Func <Advertisement, bool> > searchName;
if (string.IsNullOrEmpty(input.Search))
{
searchName = d => d.Category.LanguageId == input.LanguageId && d.Operator == _currentUser.User.UserName && d.Deleted != true;
}
else
{
searchName = d => d.Category.LanguageId == input.LanguageId && d.Operator == _currentUser.User.UserName && d.Deleted != true && (d.KeyWord.Contains(input.Search));
}
input.Func = searchName;
switch (input.Order)
{
case "Category":
return(View(_context.GetSearchResult(input, d => d.Category.Name, new string[] { "Category" }, false)));
case "KeyWord":
return(View(_context.GetSearchResult(input, d => d.KeyWord, new string[] { "Category" }, false)));
case "StartDate":
return(View(_context.GetSearchResult(input, d => d.ValidStartDate, new string[] { "Category" }, false)));
case "EndDate":
return(View(_context.GetSearchResult(input, d => d.ValidEndDate, new string[] { "Category" }, false)));
case "ShortDescription":
return(View(_context.GetSearchResult(input, d => d.ShortDescription, new string[] { "Category" }, false)));
default:
return(View(_context.GetSearchResult(input, d => d.OperationDate, new string[] { "Category" }, false)));
}
}
private void ExportCondition(ConditionViewModel conditionViewModel)
{
Microsoft.Win32.SaveFileDialog saveFileDialog = new Microsoft.Win32.SaveFileDialog();
saveFileDialog.Filter = "XML Document|*.xml";
saveFileDialog.Title = "Save Condition";
saveFileDialog.FileName = conditionViewModel.Name;
if (saveFileDialog.ShowDialog() == true)
{
try
{
string ext = System.IO.Path.GetExtension(saveFileDialog.FileName);
if (ext == ".xml")
{
string xml = _xmlExporter.FormatXMLWithHeader(_xmlExporter.GetXML(conditionViewModel.ConditionModel));
System.IO.File.WriteAllText(saveFileDialog.FileName, xml, System.Text.Encoding.UTF8);
}
else
{
_dialogService.ShowConfirmationDialog("Unable To Export", "Invalid file extension.", "OK", null, null);
}
}
catch (Exception)
{
_dialogService.ShowConfirmationDialog("Unable To Export", "An error occurred when attempting to export the condition.", "OK", null, null);
}
}
}
private void EditCondition(ConditionViewModel conditionModel)
{
_editConditionXML = conditionModel.XML;
OnPropertyChanged(nameof(EditingConditionXML));
OnPropertyChanged(nameof(IsEditingCondition));
}
public ActionResult <ConditionViewModel> Put([FromBody] ConditionViewModel model)
{
try
{
if (ModelState.IsValid)
{
var updateCondition = _mapper.Map <ConditionViewModel, Condition>(model);
_context.Update(updateCondition);
if (_context.SaveChanges() == 1)
{
return(Ok(_mapper.Map <Condition, ConditionViewModel>(updateCondition)));
}
else
{
return(BadRequest("Failed to update the Condition"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
string error = $"Error when updating the condition: {ex.Message}";
_logger.LogError(error);
return(BadRequest(error));
}
}
public ActionResult Index(string id = "Undefined")
{
var condition = new ConditionViewModel <UserFile>()
{
ChangeOrderDirection = false, OrderDirection = "desc"
};
if (string.IsNullOrEmpty(id))
{
condition.Func = d => d.Deleted != true && d.Category == "Undefined";
}
else
{
condition.Func = d => d.Deleted != true && d.Category == id;
}
condition.PerPageSize = 300;
condition.CurrentPage = 1;
var viewModel = new UploadFileViewModel();
viewModel.CategoryList = _db.Get <UserFile>(d => d.Deleted != true).GroupBy(d => d.Category).Select(g => new SelectListItem
{
Text = g.Key,
Value = g.Key,
Selected = g.Key == id
}).ToArray();
viewModel.Data = _db.GetSearchResult(condition, d => d.OperationDate, null);
return(View(viewModel));
}
public ActionResult Index(ConditionViewModel <Advertisement, AdvertisementViewModel> input)
{
input.Search = input.Search ?? "";
Expression <Func <Advertisement, bool> > searchName;
long categoryId = long.Parse(input.SearchTwo);
var category = _db.Categories.Find(categoryId);
if (category.Order == 0)
{
searchName = t => t.Category.LanguageId == category.LanguageId && t.KeyWord.Contains(input.Search) && t.Deleted != true;
}
else
{
searchName = t => t.CategoryId == categoryId && t.KeyWord.Contains(input.Search) && t.Deleted != true;
}
input.Func = searchName;
switch (input.Order)
{
case "Date":
return(View(_db.GetSearchResult(input, d => d.ValidStartDate, new string[] { "category" }, false)));
case "Area":
return(View(_db.GetSearchResult(input, d => d.Area, new string[] { "category" }, false)));
case "Popular":
return(View(_db.GetSearchResult(input, d => d.Popular, new string[] { "category" }, false)));
default:
return(View(_db.GetSearchResult(input, d => d.Id, new string[] { "category" }, false)));
}
}
private void SelectPrevious()
{
if (_conditions.Any())
{
ConditionListItemViewModel selected = _conditions.FirstOrDefault(x => x.IsSelected);
foreach (ConditionListItemViewModel condition in _conditions)
{
condition.IsSelected = false;
}
if (selected == null)
{
_conditions[_conditions.Count - 1].IsSelected = true;
_selectedCondition = new ConditionViewModel(_conditions[_conditions.Count - 1].ConditionModel);
}
else
{
int index = Math.Max(_conditions.IndexOf(selected) - 1, 0);
_conditions[index].IsSelected = true;
_selectedCondition = new ConditionViewModel(_conditions[index].ConditionModel);
}
OnPropertyChanged(nameof(SelectedCondition));
}
}
public ActionResult <ConditionViewModel> Create([FromBody] ConditionViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newCondition = _mapper.Map <ConditionViewModel, Condition>(model);
_context.Add(newCondition);
if (_context.SaveChanges() == 1)
{
return(Created($"/api/Condition/{newCondition.ConditionId}", _mapper.Map <Condition, ConditionViewModel>(newCondition)));
}
else
{
return(BadRequest("Failed to create the new Condition"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
string error = $"Error when creating a new Condition: {ex.Message}";
_logger.LogError(error);
return(BadRequest(error));
}
}
public ActionResult AlumniPublic(ConditionViewModel <ApplicationUser> input)
{
Expression <Func <ApplicationUser, bool> > searchName;
if (string.IsNullOrEmpty(input.Search))
{
searchName = t => t.Public;
}
else
{
searchName = t => t.Public && (t.UserName.Contains(input.Search) || t.Company.Contains(input.Search) || t.StudentId.Contains(input.Search) || t.JobTitle.Contains(input.Search));
}
input.Func = searchName;
var includes = new string[] { };
ConditionViewModel <ApplicationUser> models = new ConditionViewModel <ApplicationUser>();
switch (input.Order)
{
case "UserName":
models = _context.GetSearchResult(input, d => d.UserName, includes, false);
break;
case "Company":
models = _context.GetSearchResult(input, d => d.Company, includes, false);
break;
case "StudentId":
models = _context.GetSearchResult(input, d => d.StudentId, includes, false);
break;
case "Position":
models = _context.GetSearchResult(input, d => d.JobTitle, includes, false);
break;
case "Relevent":
models = _context.GetSearchResult(input, d => d.Relevent, includes, false);
break;
default:
models = _context.GetSearchResult(input, d => d.UpdateDatetime, includes, false);
break;
}
foreach (var item in models.Data)
{
var des = item.Description;
if (des == null)
{
continue;
}
var start = des.IndexOf("<p>");
var end = des.IndexOf("</p>");
if (start == -1 || end == -1)
{
continue;
}
item.Description = des.Substring(start, end - start);
}
return(View(models));
}
public static void SetYear(this ConditionViewModel c, DateTime v)
{
if (c is DateTimeConditionViewModel d)
{
d.Operator = DateTimeConditionViewModel.YearOperator.Token;
d.Value = new DateTime(v.Year, 1, 1);
}
}
public static void SetDate(this ConditionViewModel c, DateTime v)
{
if (c is DateTimeConditionViewModel d)
{
d.Operator = DateTimeConditionViewModel.DateOperator.Token;
d.Value = v.Date;
}
}
private void Delete()
{
if (_selectedCondition != null)
{
bool canDelete = true;
foreach (CharacterModel character in _compendium.Characters)
{
foreach (AppliedConditionModel condition in character.Conditions)
{
if (condition.ConditionModel != null && condition.ConditionModel.Id == _selectedCondition.ConditionModel.Id)
{
canDelete = false;
break;
}
}
if (!canDelete)
{
break;
}
}
if (canDelete)
{
string message = String.Format("Are you sure you want to delete {0}?",
_selectedCondition.Name);
bool?result = _dialogService.ShowConfirmationDialog("Delete Condition", message, "Yes", "No", null);
if (result == true)
{
_compendium.DeleteCondition(_selectedCondition.ConditionModel.Id);
ConditionListItemViewModel listItem = _conditions.FirstOrDefault(x => x.ConditionModel.Id == _selectedCondition.ConditionModel.Id);
if (listItem != null)
{
_conditions.Remove(listItem);
}
_selectedCondition = null;
_compendium.SaveConditions();
OnPropertyChanged(nameof(SelectedCondition));
if (_editConditionCommand != null)
{
CancelEditCondition();
}
}
}
else
{
_dialogService.ShowConfirmationDialog("Unable Delete Condition", "Condition is in use by a character.", "OK", null, null);
}
}
}
public void Fix(ConditionViewModel conditionViewModel)
{
conditionViewModel.Conditions.Clear();
if (conditionViewModel.InputId == null)
{
conditionViewModel.InputId = conditionViewModel.Owner.Inputs.FirstOrDefault()?.Id;
}
}
public async Task <IActionResult> AddCondition(ConditionViewModel input)
{
if (this.ModelState.IsValid)
{
await this.condiitonsService.CreateProductConditionAsync(input);
}
return(this.Redirect("/Products/ManageConditions"));
}
public void Fix(ConditionViewModel conditionViewModel)
{
conditionViewModel.InputId = null;
while (conditionViewModel.Conditions.Count > 1)
{
conditionViewModel.Conditions.RemoveAt(conditionViewModel.Conditions.Count - 1);
}
}
protected override async Task <(RecipeAction ToSave, ConditionViewModel showViewModel)> BuildModel(
ConditionViewModel viewModel, RecipeAction mainModel)
{
if (ModelState.IsValid)
{
mainModel.Set <ConditionData>(viewModel);
return(mainModel, null);
}
return(null, viewModel);
}
public IActionResult GetTranspotRequestWaitingFromDataBase([FromBody] ConditionViewModel condition)
{
var hasData = this.repositoryTransportReq.RequestionWaiting(condition);
if (hasData != null)
{
return(new JsonResult(hasData, this.DefaultJsonSettings));
}
return(NotFound(new { Error = "transport data this week has not been found" }));
}
public ActionResult Index()
{
var languageId = HttpContext.GetLanguageId();
var condition = new ConditionViewModel <Advertisement, AdvertisementViewModel>()
{
LanguageId = languageId, ChangeOrderDirection = false, OrderDirection = "desc"
};
condition.Func = d => d.Category.LanguageId == languageId && d.Operator == _currentUser.User.UserName && d.Deleted != true;
var vm = _context.GetSearchResult(condition, d => d.OperationDate, new string[] { "Category" });
return(View(vm));
}
public ActionResult MedicalHistory(string ID)
{
SearchViewModel m = new SearchViewModel();
List <ConditionViewModel> conditionList = new List <ConditionViewModel>();
var client = new FhirClient("http://fhirtest.uhn.ca/baseDstu1");
//search patients based on patientID clicked
Bundle resultsPatients = client.Search <Patient>(new string[] { "_id=" + ID });
//gets patient based on ID
foreach (var entry in resultsPatients.Entries)
{
ResourceEntry <Patient> patient = (ResourceEntry <Patient>)entry;
m = getPatientInfo(patient);
}
Bundle resultsConditions = client.Search <Condition>(new string[] { "subject=" + ID });
foreach (var entry in resultsConditions.Entries)
{
ConditionViewModel conditions = new ConditionViewModel();
ResourceEntry <Condition> condition = (ResourceEntry <Condition>)entry;
if (condition.Resource.Code != null)
{
conditions.ConditionName = condition.Resource.Code.Text;
}
else
{
conditions.ConditionName = "Unknown";
}
if (condition.Resource.Onset != null)
{
conditions.Date = (condition.Resource.Onset as Date).Value;
}
else
{
conditions.Date = "Unknown";
}
m.ConditionsCount++;
conditionList.Add(conditions);
}
m.Conditions = conditionList;
patients.Add(m);
return(View(patients));
}
/// <summary>
/// Shows details dialog
/// </summary>
public void ShowDetailsDialog(ConditionViewModel conditionViewModel)
{
ModalDialog modalDialog = new ModalDialog();
if (_parentWindow != null)
{
modalDialog.Owner = _parentWindow;
}
modalDialog.WindowTitle = conditionViewModel.Name;
modalDialog.Body = new DetailsView(conditionViewModel);
ShowDialog(modalDialog);
}
private void SelectCondition(ConditionListItemViewModel conditionItem)
{
bool selectCondition = true;
if (_editConditionXML != null)
{
if (_editHasUnsavedChanges)
{
string body = String.Format("{0} has unsaved changes.{1}What would you like to do?",
_selectedCondition.Name, Environment.NewLine + Environment.NewLine);
string accept = "Save and Continue";
string reject = "Discard Changes";
string cancel = "Cancel Navigation";
bool? result = _dialogService.ShowConfirmationDialog("Unsaved Changes", body, accept, reject, cancel);
if (result == true)
{
if (!SaveEditCondition())
{
selectCondition = false;
}
}
else if (result == false)
{
CancelEditCondition();
}
else
{
selectCondition = false;
}
}
else
{
CancelEditCondition();
}
}
if (selectCondition)
{
foreach (ConditionListItemViewModel item in _conditions)
{
item.IsSelected = false;
}
conditionItem.IsSelected = true;
_selectedCondition = new ConditionViewModel(conditionItem.ConditionModel);
OnPropertyChanged(nameof(SelectedCondition));
}
}
public IHttpActionResult Get(int categoryId = 0, string search = "none", string sort = "id", string includes = null, string fields = null, int page = 1, int pageSize = maxPageSize)
{
try
{
var Con = new ConditionViewModel <Advertisement>();
Con.Func = d => d.Category.LanguageId == 1 && (categoryId == 0 || d.CategoryId == categoryId) && (search == "none" || d.KeyWord.Contains(search)) && d.Deleted == false;
Con.CurrentPage = page;
Con.PerPageSize = pageSize;
var result = _db.GetSearchResult(Con, sort, includes, fields);
var urlHelper = new UrlHelper(Request);
var prevLink = result.CurrentPage > 1 ? urlHelper.Link("advertisementList",
new
{
page = result.CurrentPage - 1,
pageSize = result.PerPageSize,
sort = sort,
fields = fields,
categoryId = categoryId
}) : "";
var nextLink = result.CurrentPage < result.TotalPages ? urlHelper.Link("advertisementList",
new
{
page = result.CurrentPage + 1,
pageSize = result.PerPageSize,
sort = sort,
fields = fields,
categoryId = categoryId
}) : "";
var paginationHeader = new
{
currentPage = result.CurrentPage,
pageSize = result.PerPageSize,
totalPages = result.TotalPages,
previousPageLink = prevLink,
nextPageLink = nextLink
};
HttpContext.Current.Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationHeader));
// return result
return(Ok(result.ApiData));
}
catch (Exception)
{
return(InternalServerError());
}
}
public IHttpActionResult Get(string sort = "id", string includes = null, string fields = null, string search = "1", int page = 1, int pageSize = maxPageSize)
{
try
{
int languageId = int.Parse(search);;
var Con = new ConditionViewModel <Category>();
Con.Func = d => d.LanguageId == languageId;
Con.CurrentPage = page;
Con.PerPageSize = pageSize;
var result = _db.GetSearchResult(Con, sort, includes, fields);
return(Ok(result.ApiData));
}
catch (Exception)
{
return(InternalServerError());
}
}
public virtual ConditionViewModel <T> GetSearchResult <T>(ConditionViewModel <T> Condition, string Sort = "id", string Includes = null, string Fields = null) where T : class
{
var result = new ConditionViewModel <T>();
IQueryable <T> group;
if (Condition.Func == null)
{
Condition.Func = d => true;
}
int total = Set <T>().Count(Condition.Func);
var totalPages = total / Condition.PerPageSize + (total % Condition.PerPageSize > 0 ? 1 : 0);
if (Condition.CurrentPage > totalPages)
{
Condition.CurrentPage = 1;
}
group = Set <T>().Where(Condition.Func).ApplySort(Sort).Skip((Condition.CurrentPage - 1) * Condition.PerPageSize)
.Take(Condition.PerPageSize);
List <string> includeFields = new List <string>();
// contains "expenses", or "others", …
if (Includes != null)
{
includeFields = Includes.ToLower().Split(',').ToList();
}
if (includeFields != null)
{
foreach (var item in includeFields)
{
group = group.Include(item);
}
}
var temp = group.ToList();
result.ApiData = group.ToList().Select(d => ShapedObject(d, Fields));
result.TotalPages = totalPages == 0 ? 1 : totalPages;
result.PerPageSize = Condition.PerPageSize;
result.CurrentPage = Condition.CurrentPage;
result.Search = Condition.Search;
result.SearchTwo = Condition.SearchTwo;
return(result);
}
public async Task CreateConditionShouldCreateNewCondition()
{
var options = new DbContextOptionsBuilder <WHMSDbContext>().UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
using var context = new WHMSDbContext(options);
var service = new ConditionsService(context);
var testCondition = new ConditionViewModel {
Name = "Test", Description = "Description"
};
var conditionId = await service.CreateProductConditionAsync(testCondition);
var condition = context.ProductConditions.FirstOrDefault();
Assert.Equal(condition.Id, conditionId);
Assert.Equal(condition.Name, testCondition.Name);
Assert.Equal(condition.Description, testCondition.Description);
}
public static Condition Create(ConditionViewModel conditionViewModel)
{
return(new Condition
{
Id = conditionViewModel.Id,
Configuration = conditionViewModel.Configuration,
Type = conditionViewModel.Type,
Inputs = conditionViewModel.Inputs,
//ModuleType members
Uid = conditionViewModel.Uid,
Outputs = conditionViewModel.Outputs?.FromViewModels(),
Visibility = conditionViewModel.Visibility,
Tags = conditionViewModel.Tags?.FromViewModels(),
Label = conditionViewModel.Label,
Description = conditionViewModel.Description,
ConfigDescriptions = conditionViewModel.ConfigDescriptions?.FromViewModels()
});
}
public ActionResult Index(ConditionViewModel <ApplicationUser> input)
{
Expression <Func <ApplicationUser, bool> > searchName;
if (string.IsNullOrEmpty(input.Search))
{
searchName = t => true;
}
else
{
searchName = t => t.UserName.Contains(input.Search) || t.Company.Contains(input.Search) || t.StudentId.Contains(input.Search) || t.JobTitle.Contains(input.Search);
}
input.Func = searchName;
var includes = new string[] { };
switch (input.Order)
{
case "UserName":
return(View(_context.GetSearchResult(input, d => d.UserName, includes, false)));
case "Company":
return(View(_context.GetSearchResult(input, d => d.Company, includes, false)));
case "StudentId":
return(View(_context.GetSearchResult(input, d => d.StudentId, includes, false)));
case "Position":
return(View(_context.GetSearchResult(input, d => d.JobTitle, includes, false)));
case "Relevent":
return(View(_context.GetSearchResult(input, d => d.Relevent, includes, false)));
default:
return(View(_context.GetSearchResult(input, d => d.UpdateDatetime, includes, false)));
}
}
public void Fix(ConditionViewModel conditionViewModel)
{
}
private static string CreateBrowseValue(ConditionViewModel c)
{
var tagsBrowseValue = c.Tags != null?string.Join(string.Empty, c.Tags) : string.Empty;
return($"{c.Label}{c.Label}{c.Type}{c.Uid}{c.Description}{tagsBrowseValue}");
}
public static void CreateCondition(object sender, object selectedItem)
{
if (selectedItem is ConditionCollectionViewModel collectionViewModel)
{
CreateCondition(sender, collectionViewModel.Parent);
return;
}
if (!(selectedItem is GroupViewModel entityGroupViewModel))
{
return;
}
var button = (Button)sender;
var type = (string)button.CommandParameter;
CompareConditionBase entity;
switch (type)
{
case nameof(When):
entity = When.New("ValueA", "ValueB");
break;
case nameof(WhenNot):
entity = WhenNot.New("ValueA", "ValueB");
break;
case nameof(WhenGreaterThan):
entity = WhenGreaterThan.New("ValueA", "ValueB");
break;
case nameof(WhenGreaterThanEqualTo):
entity = WhenGreaterThanEqualTo.New("ValueA", "ValueB");
break;
case nameof(WhenLessThan):
entity = WhenLessThan.New("ValueA", "ValueB");
break;
case nameof(WhenLessThanEqualTo):
entity = WhenLessThanEqualTo.New("ValueA", "ValueB");
break;
case nameof(WhenEqualTo):
entity = WhenEqualTo.New("ValueA", "ValueB");
break;
case nameof(WhenNotEqualTo):
entity = WhenNotEqualTo.New("ValueA", "ValueB");
break;
case nameof(WhenContains):
entity = WhenContains.New("ValueA", "ValueB");
break;
case nameof(WhenNotContains):
entity = WhenNotContains.New("ValueA", "ValueB");
break;
case nameof(WhenWithinArray):
entity = WhenWithinArray.New("Item1,Item2", "ValueB");
break;
case nameof(WhenNotWithinArray):
entity = WhenNotWithinArray.New("Item1,Item2", "ValueB");
break;
default:
throw new ArgumentOutOfRangeException();
}
entityGroupViewModel.Element.Conditions.Add(entity);
var viewModelCollection = entityGroupViewModel.Children.OfType <ConditionCollectionViewModel>().First();
var viewModel = new ConditionViewModel(entity, viewModelCollection);
viewModelCollection.Children.Add(viewModel);
entityGroupViewModel.IsExpanded = true;
viewModelCollection.IsExpanded = true;
viewModel.IsSelected = true;
viewModel.IsExpanded = true;
}
