public string CreateState(StateViewModel stateViewModel)
{
if (ModelState.IsValid)
{
var result = iUnitOfWork.Repository <State>().GetMany(x => x.Name == stateViewModel.StateName).Any();
if (!result)
{
try
{
State state = new State();
state.Name = stateViewModel.StateName;
state.IsActive = true;
state.CountryId = stateViewModel.CountryId;
iUnitOfWork.Repository <State>().Add(state);
bool save = iUnitOfWork.Commit();
return("Added Successfully");
}
catch (Exception exception)
{
System.Diagnostics.Debug.WriteLine(exception);
return("Some internal Error Occure");
}
}
else
{
return("State Already Exists");
}
}
return("Please try after some time");
}
public FiniteAutomationWindow()
{
InitializeComponent();
StateViewModel stateViewModel = new StateViewModel();
DataContext = stateViewModel;
}
public async Task <IActionResult> Edit(StateViewModel model)
{
if (ModelState.IsValid)
{
var storeobj = _unitofWork.state.Get(model.id);
if (storeobj == null)
{
TempData["error"] = "Record Not Found";
return(NotFound());
}
storeobj.id = model.id;
storeobj.Name = model.Name;
storeobj.countryid = model.countryid;
_unitofWork.state.Update(storeobj);
_unitofWork.Save();
TempData["success"] = "Record Update successfully";
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
// [TypeFilter(typeof(AuthorizeAction), Arguments = new object[] { "Read" })]
public IActionResult SummaryView()
{
StateViewModel model = new StateViewModel();
InitAccessModel(model);
return(View(model));
}
public void BuildRulesTest()
{
var f = new StateViewModel { Name = "false" };
var t = new StateViewModel { Name = "true" };
var validStates = new List<StateViewModel>(new[] { t, f });
for (int i = 0; i < 3; i++)
DecisionTable.Conditions.Add(new ConditionViewModel { Name = string.Format("Condition {0}", i), ValidStates = validStates });
for (int i = 0; i < 2; i++)
DecisionTable.Actions.Add(new ActionViewModel { Name = string.Format("Action {0}", i) });
var actual = DecisionTableViewModelUtils.Instance.BuildRules(DecisionTable);
Assert.IsTrue(actual.Count == 8);
var expectedStates = new Dictionary<ConditionViewModel, List<StateViewModel>>
{
{ DecisionTable.Conditions[0], new StateViewModel[] { t, t, t, t, f, f, f, f }.ToList() },
{ DecisionTable.Conditions[1], new StateViewModel[] { t, t, f, f, t, t, f, f }.ToList() },
{ DecisionTable.Conditions[2], new StateViewModel[] { t, f, t, f, t, f, t, f }.ToList() },
};
for (int ruleIndex = 0; ruleIndex < actual.Count; ruleIndex++)
{
var actualRule = actual[ruleIndex];
foreach (var actualPair in actualRule.ConditionStates)
{
var condition = actualPair.Key;
var actualState = actualPair.Value;
var expectedState = expectedStates[condition];
Assert.AreEqual(expectedState[ruleIndex], actualState);
}
}
}
// GET: State/Edit/5
public ActionResult Edit(int?id)
{
loadcountry();
StateViewModel StateViewModel = StateServices.GetByID(id);
return(View(StateViewModel));
}
public IActionResult Create()
{
ViewBag.countrylist = _unitofWork.country.GetAll().ToList();
var model = new StateViewModel();
return(View(model));
}
//[AuthorizeUser(RoleModule.State, Function.Create)]
public JsonResult Insert(StateViewModel sViewModel)
{
Set_Date_Session(sViewModel.State);
using (TransactionScope tran = new TransactionScope())
{
try
{
sViewModel.State.StateId = _stManager.Insert_StateMaster(sViewModel.State);
sViewModel.FriendlyMessage.Add(MessageStore.Get("STATE01"));
tran.Complete();
Logger.Debug("State Controller Insert");
}
catch (Exception ex)
{
tran.Dispose();
sViewModel.FriendlyMessage.Add(MessageStore.Get("SYS01"));
Logger.Error("State Controller - Insert " + ex.Message);
}
}
return(Json(sViewModel));
}
private void InitializeViews(int?state_id, int?country_id)
{
State state;
SelectList countriesList;
if (state_id != null)
{
state = _stateService.GetById((int)state_id);
countriesList = new SelectList(new CountriesServices().GetCountriesForDropDownList(), "Key", "Value", state.Country_Id);
}
else
{
state = new State();
if (country_id != null)
{
countriesList = new SelectList(new CountriesServices().GetCountriesForDropDownList(), "Key", "Value", country_id);
state.Country_Id = country_id.Value;
}
else
{
countriesList = new SelectList(new CountriesServices().GetCountriesForDropDownList(), "Key", "Value");
}
}
_stateViewModel = new StateViewModel(state, countriesList);
}
public ActionResult Create([Bind(Include = "Id,Name,Flag")] StateViewModel state, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
var photoUrl = Upload(file);
state.Flag = photoUrl.Substring(1, photoUrl.Length - 2);
var client = GlobalWebApiClient.GetClientRegion();
var response = client.PostAsJsonAsync("api/states/save/", state).Result;
try
{
if (response.IsSuccessStatusCode)
{
state = response.Content.ReadAsAsync <StateViewModel>().Result;
TempData["SuccessMessage"] = "State created successfully";
return(RedirectToAction("Details", state));
}
}
catch (Exception ex)
{
var result = ex.Message;
}
}
else
{
ModelState.AddModelError(string.Empty, "Server Error. Please contact administrator.");
}
return(View(state));
}
public ActionResult MasterPartial(int masterCode)
{
StateViewModel stateVM = masterCode == 0 ? new StateViewModel() : Mapper.Map <State, StateViewModel>(_stateBusiness.GetState(masterCode));
stateVM.IsUpdate = masterCode == 0 ? false : true;
return(PartialView("_AddState", stateVM));
}
private IHttpActionResult InsertState(StateViewModel StateVM)
{
try
{
if (!IsNameStateAvailble(StateVM.Name, StateVM))
{
return(Json(new { Result = "ERROR", Message = "State Name already exists" }));
}
State StateADD = new State
{
Name = StateVM.Name,
IsActive = StateVM.IsActive,
CountryID = StateVM.CountryID,
IsSystem = false
};
_repository.StateRepository.Add(StateADD);
if (_repository.StateRepository.Save((WindowsPrincipal)User) > 0)
{
var Record = _repository.StateRepository.GetField(StateADD.ID);
return(Json(new { Result = "OK", Record = StateADD }));
}
else
{
return(Json(new { Result = "ERROR", Message = Errors.MessageError }));
}
}
catch (Exception ex)
{
return(Json(new { Result = "ERROR", Message = Errors.Write(ex) }));
}
}
private IHttpActionResult UpdateState(StateViewModel StateVM)
{
try
{
if (!IsNameStateAvailble(StateVM.Name, StateVM))
{
return(Json(new { Result = "ERROR", Message = "State Name already exists" }));
}
State StateUpdated = _repository.StateRepository.Find(StateVM.ID);
StateUpdated.Name = StateVM.Name;
StateUpdated.IsActive = StateVM.IsActive;
StateUpdated.CountryID = StateVM.CountryID;
_repository.StateRepository.Edit(StateUpdated);
if (_repository.StateRepository.Save((WindowsPrincipal)User) > 0)
{
var Record = _repository.StateRepository.GetField(StateVM.ID);
return(Json(new { Result = "OK", Record = Record }));
}
else
{
return(Json(new { Result = "ERROR", Message = Errors.MessageError }));
}
}
catch
{
return(Json(new { Result = "ERROR", Message = Errors.MessageError }));
}
}
public ActionResult Create()
{
var model = new StateViewModel();
model.Cntries = new SelectList(_CountryService.GetAll(), "Id", "Name");
return(View(model));
}
public async Task <IActionResult> Create(StateViewModel model)
{
if (ModelState.IsValid)
{
var objcategory = new state
{
id = model.id
,
Name = model.Name
,
countryid = model.countryid
,
isdeleted = false
,
isactive = false
};
_unitofWork.state.Add(objcategory);
_unitofWork.Save();
TempData["success"] = "Record Save successfully";
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
// GET: State/Create
public ActionResult CreateState()
{
var res = new StateViewModel();
res.Countries = serviceCountry.GetMany().ToSelectListItems();
return(View(res));
}
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (_viewModel == null)
{
_viewModel = DataContext as StateViewModel;
}
var rectangle = (Template.FindName("PART_RectangleFrame", this) as Path).Data as RectangleGeometry;
var rect = rectangle.Rect;
if (double.IsNaN(Width))
{
Width = rect.Width;
}
else
{
rect.Width = Width;
}
if (double.IsNaN(Height))
{
Height = rect.Height;
}
else
{
rect.Height = Height;
}
rectangle.Rect = rect;
}
public IActionResult Create(StateViewModel model)
{
//Validate the model
if (!ModelState.IsValid)
{
BindCountries(model);
return(View(model));
}
try
{
State state = new State()
{
CountryId = model.CountryId,
Name = model.Name
};
_stateRepository.Create(state);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(model));
}
}
// GET: Country/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
//Fetch contact from db by passed id
var state = _stateRepository.GetById(id);
if (state == null)
{
return(NotFound());
}
StateViewModel model = new StateViewModel()
{
Id = state.Id,
CountryId = state.CountryId,
Name = state.Name
};
BindCountries(model);
return(View(model));
}
public bool DeleteStateList(StateViewModel stateViewModel)
{
using (var connection = new SqlConnection(connectionString))
{
try
{
SqlParameter[] parameters = new SqlParameter[] {
new SqlParameter("@countryCode", stateViewModel.CountryCode),
new SqlParameter("@stateCode", stateViewModel.StateCode),
};
var data =
SqlHelper.ExecuteNonQuery
(
connection,
CommandType.StoredProcedure,
"usp_DeleteState",
parameters
);
if (data > 0)
{
return(true);
}
}
finally
{
SqlHelper.CloseConnection(connection);
}
}
throw new DataNotUpdatedException("Unable to delete data");
}
public IActionResult Update(int id, StateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
//Fetch country from db
State state = _stateRepository.GetById(id);
if (state == null)
{
return(NotFound());
}
try
{
//Set properties to edited values
state.CountryId = model.CountryId;
state.Name = model.Name;
_stateRepository.Update(state);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View("Error"));
}
}
//Add
public ActionResult Add()
{
ViewBag.Title = "Add State";
var stateViewModel = new StateViewModel();
return(View("AddEdit", stateViewModel));
}
public JsonResult GetStates(StateViewModel sViewModel)
{
PaginationInfo pager = new PaginationInfo();
pager = sViewModel.Pager;
PaginationViewModel pViewModel = new PaginationViewModel();
try
{
pViewModel.dt = _sRepo.GetStates(sViewModel.State.CountryId, sViewModel.State.StateCode, sViewModel.State.StateName, ref pager);
pViewModel.Pager = pager;
Logger.Debug("State Controller GetStates");
}
catch (Exception ex)
{
sViewModel.FriendlyMessage.Add(MessageStore.Get("SYS01"));
Logger.Error("State Controller - GetStates" + ex.ToString());
}
return(Json(JsonConvert.SerializeObject(pViewModel), JsonRequestBehavior.AllowGet));
}
public ActionResult Create(StateViewModel model)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var state = AutoMapper.Mapper.Map <State>(model);
state.CreatedOn = DateTime.Now;
state.UpdatedOn = DateTime.Now;
var isSave = stateService.SaveState(state);
if (isSave > 0)
{
return(RedirectToAction("Index"));
}
}
}
catch
{
return(View(model));
}
return(View(model));
}
public ActionResult AddUpdateState(StateViewModel stateViewModel)
{
try
{
//stateViewModels.Insert(0, stateViewModel);
var stateResult = new ServiceResponseModel();
if (stateViewModel.Id < 1)
{
stateResult = webServices.Post(stateViewModel, "Country/AddUpdateState");
}
else
{
stateResult = webServices.Post(stateViewModel, "Country/AddUpdateState");
}
if (stateResult.StatusCode == System.Net.HttpStatusCode.Accepted)
{
var reuslt = (new JavaScriptSerializer().Deserialize <int>(stateResult.Data));
return(RedirectToAction(nameof(StateAll)));
}
return(View(stateResult));
}
catch (Exception ex)
{
throw ex;
}
}
//[ValidateAntiForgeryToken]
public JsonResult CreateEdit(StateViewModel state)
{
try
{
if (state.ID <= 0)
{
var data = _stateService.StateNameExists(state.StateName);
if (data != null)
{
ModelState.AddModelError("StateName", "State Name Already Exists");
return(Json(state));
}
_stateService.SaveRecord(state);
}
else
{
_stateService.SaveRecord(state);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
ViewBag.CountryList = new SelectList(_stateService.GetCountryMasterList(), "CountryID", "CountryName");
return(Json(state));
}
public ActionResult State()
{
ButtonVisiblity("Index");
var model = new StateViewModel();
ViewBag.CountryList = new SelectList(dd._context.Mst_Country.ToList(), "Cn_id", "Cn_Name");
return(View(model));
}
public ActionResult Index(StateViewModel sViewModel)
{
Set_Date_Session(sViewModel.State);
sViewModel.Countries = _sRepo.drpGetCountries();
return(View("Index", sViewModel));
}
public ActionResult ViewState(string state)
{
StateViewModel model = new StateViewModel();
model.StateName = Helper.stateAbbreviationExpand(state);
model.Cities = db.Cities.Where(c => c.State == state).ToList();
return(View(model));
}
//コンストラクタ
public TcpMessageClient(StateViewModel clientStateViewModel)
{
//インスタンス生成
client = new TcpClient();
//ビューモデル格納
ClientStateViewModel = clientStateViewModel;
}
//コンストラクタ
public UdpMessageClient(StateViewModel clientStateViewModel)
{
//ビューモデル格納
ClientStateViewModel = clientStateViewModel;
//スレッド開始（返り値を破棄してコンストラクタを終了）
_ = StartThreadAsync();
}
public void Read()
{
// TO DO : Read ALL
List<MYFAN.BusinessObjects.State> categories = (new MYFAN.BusinessLogic.State()).ReadAll();
foreach (var item in categories)
{
StateViewModel vm = new StateViewModel();
vm.MapFrom(item);
_StateList.Add(vm);
}
}
void OnStateChanged()
{
OnPropertyChanged(() => DevicePicture);
States = new List<StateViewModel>();
foreach (var state in DeviceState.ThreadSafeStates)
{
var stateViewModel = new StateViewModel(state.DriverState, DeviceState.Device);
States.Add(stateViewModel);
}
ParentStates = new List<StateViewModel>();
foreach (var state in DeviceState.ThreadSafeParentStates)
{
var stateViewModel = new StateViewModel(state.DriverState.Clone())
{
DeviceName = state.ParentDevice.DottedPresentationAddressAndName
};
ParentStates.Add(stateViewModel);
}
OnPropertyChanged("StateType");
OnPropertyChanged("States");
OnPropertyChanged("ParentStringStates");
OnPropertyChanged("IsAutomaticOff");
var property = Device.Properties.FirstOrDefault(x => x.Name == "EnableCountDownTimer");
if (property != null && property.Value == "1")
{
StartTimer(DriverType.RM_1, "RMOn");
StartTimer(DriverType.MRO, "MRO_On");
StartTimer(DriverType.MRO_2, "MRO_On");
StartTimer(DriverType.MDU, "ClapanOn1e");
StartTimer(DriverType.Valve, "Bolt_On");
StartTimer(DriverType.MPT, "MPT_On");
}
}
public void ReindexRulesTest()
{
var f = new StateViewModel { Name = "false" };
var t = new StateViewModel { Name = "true" };
var validConditionStates = new List<StateViewModel>(new[] { t, f });
var conditions = new List<ConditionViewModel>();
for (int i = 0; i < 3; i++)
conditions.Add(new ConditionViewModel
{
Name = string.Format("Condition {0}", i),
});
var actualConditionStates = new Dictionary<ConditionViewModel, List<StateViewModel>>
{
{ conditions[0], new StateViewModel[] { t, t, t, t, f, f, f, f }.ToList() },
{ conditions[1], new StateViewModel[] { t, t, f, f, t, t, f, f }.ToList() },
{ conditions[2], new StateViewModel[] { t, f, t, f, t, f, t, f }.ToList() },
};
var ruleCount = actualConditionStates.First().Value.Count;
var expectedOrder = new List<RuleViewModel>();
for (int ruleIndex = 0; ruleIndex < ruleCount; ruleIndex++)
{
var conditionStates = new Dictionary<ConditionViewModel, StateViewModel>();
foreach (var pair in actualConditionStates)
conditionStates.Add(pair.Key, pair.Value[ruleIndex]);
RuleViewModel newRule = new RuleViewModel
{
Index = ruleIndex * 2,
ConditionStates = conditionStates,
};
DecisionTable.Rules.Add(newRule);
expectedOrder.Add(newRule);
}
var actual = DecisionTableViewModelUtils.Instance.ReindexRules(DecisionTable.Rules.Reverse<RuleViewModel>());
CollectionAssert.AreEqual(expectedOrder, actual);
for (int i = 0; i < actual.Count; i++)
Assert.AreEqual(i, actual[i].Index);
}
public ActionResult UpdateState(int id)
{
StateViewModel vmState = new StateViewModel();
vmState.Read(id);
return View(vmState);
}
public void CalculateRuleCountTest()
{
var f = new StateViewModel { Name = "false" };
var t = new StateViewModel { Name = "true" };
var validStates = new List<StateViewModel>(new[] { t, f });
for (int i = 0; i < 3; i++)
DecisionTable.Conditions.Add(new ConditionViewModel { Name = string.Format("Condition {0}", i), ValidStates = validStates });
for (int i = 0; i < 2; i++)
DecisionTable.Actions.Add(new ActionViewModel { Name = string.Format("Action {0}", i) });
DecisionTableViewModelUtils_Accessor target = new DecisionTableViewModelUtils_Accessor();
var actual = target.CalculateRuleCount(DecisionTable.Conditions);
int expected = 8;
Assert.AreEqual(expected, actual);
}
public void ResetNewStateViewModel()
{
NewState = new StateViewModel();
}
public ActionResult CreateState(StateViewModel model)
{
try
{
int id = model.Create();
if (id > 0)
{
return RedirectToAction("states");
}
}
catch (Exception)
{
}
return View(model);
}
public ActionResult UpdateState(StateViewModel model)
{
try
{
bool result = model.Update();
if (result)
{
return RedirectToAction("states");
}
}
catch (Exception)
{
}
return View(model);
}
public ActionResult CreateState()
{
StateViewModel vmState = new StateViewModel();
return View(vmState);
}
