public static void AssertStepsAreEqual(StepModel expected, StepModel actual, uint expectedTaskID)
{
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expectedTaskID, actual.TaskID);
using (var expectedHintIt = expected.Hints.GetEnumerator())
{
using (var actualHintIt = actual.Hints.GetEnumerator())
{
while (true)
{
var expectedNext = expectedHintIt.MoveNext();
var actualNext = actualHintIt.MoveNext();
Assert.IsTrue(expectedNext == actualNext);
if (!expectedNext)
{
break;
}
HintTests.AssertHintsAreEqual(expectedHintIt.Current.Value, actualHintIt.Current.Value, expectedTaskID, actual.ID);
}
}
}
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
await SetUpPage();
return(Page());
}
if (Step == null)
{
Step = new StepModel();
}
Step.Instructions = StepInstructions;
Step.SignOffIsRequired = IsSignOffRequired;
Step.StepName = StepName;
Step.StepCategory = await StepDataAccess.GetStepCategoryById(StepCategoryId);
var currentStepsWithSameName = await StepDataAccess.GetStepByName(StepName);
if (currentStepsWithSameName != null && currentStepsWithSameName.Any())
{
var stepExistsMessage = "A step with that name already exists.";
return(RedirectToPage("StepMaintenance", new { aStepId = currentStepsWithSameName[0].StepId, aMessage = stepExistsMessage }));
}
var theStepId = await StepDataAccess.PostNewStep(Step);
return(RedirectToPage("StepMaintenance", new { aStepId = theStepId.StepId, aMessage = "Step saved successfully", isMessageGood = true }));
}
public static void StepModify(StepModel StepToUpsert)
{
LogManager.Models.LogModel oLog = GetLogModel();
try
{
DAL.Controller.CustomerDataController.Instance.StepModify
(StepToUpsert.StepId,
StepToUpsert.Name,
StepToUpsert.Position);
oLog.IsSuccess = true;
}
catch (Exception err)
{
oLog.IsSuccess = false;
oLog.Message = err.Message + " - " + err.StackTrace;
throw err;
}
finally
{
oLog.LogObject = StepToUpsert;
LogManager.ClientLog.AddLog(oLog);
}
}
public async Task <List <StepModel> > ParseExcelFile()
{
try
{
_wb = new HSSFWorkbook(_importedFile);
List <StepModel> stepList = new List <StepModel>();
ISheet sheet = _wb.GetSheet("Sheet1");
for (int row = 1; row <= sheet.LastRowNum; row++)
{
if (sheet.GetRow(row) != null)
{
StepModel stepModel = new StepModel();
stepModel.Classification = sheet.GetRow(row).GetCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).StringCellValue;
stepModel.Order = sheet.GetRow(row).GetCell(1, MissingCellPolicy.CREATE_NULL_AS_BLANK).StringCellValue;
stepModel.Problem = sheet.GetRow(row).GetCell(2, MissingCellPolicy.CREATE_NULL_AS_BLANK).StringCellValue;
stepModel.Solution = sheet.GetRow(row).GetCell(3, MissingCellPolicy.CREATE_NULL_AS_BLANK).StringCellValue;
stepList.Add(stepModel);
}
}
return(stepList);
}
catch (Exception ex)
{
throw ex;
}
}
private void CreateStepController(StepModel stepModel)
{
// Ignore if step controller already exists:
if (_stepControllers.ContainsKey(stepModel.ID))
{
return;
}
// Instantiate:
var stepController = Instantiate(StepControllerPrefab);
// Set properties:
stepController.StepModel = stepModel;
stepController.CameraManager = CameraManager;
stepController.StepOrder = (uint)_stepControllers.Count + 1;
// Subscribe to events:
stepController.OnShowClicked += StepController_OnShowClicked;
stepController.OnDeleteClicked += StepController_OnDeleteClicked;
stepController.OnHintEditClicked += StepController_OnHintEditClicked;
// Add to instructions view:
InstructionsView.AddToContainer(stepController.transform);
// Add to list:
_stepControllers.Add(stepModel.ID, stepController);
// If not showing any step, show this one:
if (!_stepControllers.ContainsKey(ShowingStepID))
{
ShowingStepID = stepModel.ID;
}
}
/// <summary>
/// Insert or Update Step
/// </summary>
/// <param name="objStepModel"></param>
/// <returns></returns>
public StepModel InsertUpdateStep(StepModel objStepModel)
{
try
{
objStepModel.StepName = objStepModel.StepName.ToString().Trim();
int ErrorCode = 0;
string ErrorMessage = "";
SqlParameter pErrorCode = new SqlParameter("@ErrorCode", ErrorCode);
pErrorCode.Direction = ParameterDirection.Output;
SqlParameter pErrorMessage = new SqlParameter("@ErrorMessage", ErrorMessage);
pErrorMessage.Direction = ParameterDirection.Output;
SqlParameter[] parmList =
{
new SqlParameter("@StepID", objStepModel.StepID)
, new SqlParameter("@StepName", objStepModel.StepName)
, new SqlParameter("@StepDiscription", objStepModel.StepDiscription == null?string.Empty:objStepModel.StepDiscription)
, new SqlParameter("@IsActive", objStepModel.IsActive)
, new SqlParameter("@CreatedBy", objStepModel.CreatedBy)
, pErrorCode
, pErrorMessage
};
//If StepId is 0 Than Insert Step else Update Step
SQLHelper.ExecuteNonQuery(SQLHelper.ConnectionStringLocalTransaction, CommandType.StoredProcedure, DBConstants.Admin_InsertUpdateStep, parmList);
//set error code and message
objStepModel.ErrorCode = Convert.ToInt32(pErrorCode.Value);
objStepModel.Message = Convert.ToString(pErrorMessage.Value);
return(objStepModel);
}
catch (Exception ex)
{
throw ex;
}
}
public void StepFileHeaderVersionTest()
{
var model = new StepModel(new Ifc4.EntityFactoryIfc4());
var header = new StepFileHeader(StepFileHeader.HeaderCreationMode.InitWithXbimDefaults, model);
Assert.IsTrue(header.FileName.OriginatingSystem == model.GetType().GetTypeInfo().Assembly.GetName().Name);
Assert.IsTrue(header.FileName.PreprocessorVersion == string.Format("Processor version {0}", model.GetType().GetTypeInfo().Assembly.GetName().Version));
}
/*生命周期----------------------------------------------------------------------*/
private void Awake()
{
btnLast.interactable = false;
UpdateBestScore(PlayerPrefs.GetInt(Const.BestScore, 0));
lastStepModel = new StepModel();
InitGrid();
CreateNumber();
}
public void PostTripAddInvalidTraveler_Fails()
{
using (IDbContext idtoFakeContext = new IDTOFakeContext())
using (IUnitOfWork unitOfWork = new UnitOfWork(idtoFakeContext))
{
unitOfWork.Repository <Traveler>().Insert(new Traveler {
Id = 1, FirstName = "TestFN", LastName = "TestLN", ObjectState = ObjectState.Added
});
unitOfWork.Save();
var controller = new TripController(idtoFakeContext);
SetupControllerForTests(controller);
TripModel m = new TripModel
{
TravelerId = 50,
Origination = "Neverland",
Destination = "Montana",
TripStartDate = DateTime.Parse("10/2/2012"),
TripEndDate = DateTime.Parse("10/2/2013"),
MobilityFlag = true,
BicycleFlag = true,
PriorityCode = "1"
};
List <StepModel> steps = new List <StepModel>();
StepModel stepmodel = new StepModel();
stepmodel.StartDate = DateTime.Parse("1/1/2014 10:02");
stepmodel.EndDate = DateTime.Parse("1/1/2014 10:40");
stepmodel.FromName = "Quartz Street";
stepmodel.FromProviderId = (int)Providers.COTA;
stepmodel.FromStopCode = "1001";
stepmodel.ModeId = (int)Modes.Bus;
stepmodel.RouteNumber = "039";
stepmodel.Distance = (decimal)12.2;
stepmodel.ToName = "Slate Run Road";
stepmodel.ToProviderId = (int)Providers.COTA;
stepmodel.ToStopCode = "2002";
steps.Add(stepmodel);
m.Steps = steps;
try
{
var actionResult = controller.PostTrip(m);
Assert.AreEqual(true, false, "Test should have thrown an exception and not executed this line.");
}
catch (HttpResponseException ex)
{
Assert.AreEqual(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
// var response = actionResult as OkNegotiatedContentResult<IEnumerable<Trip>>;
// Assert.IsNotNull(response);
// var books = response.Content;
//Assert.AreEqual(5, books.Count());
// var response = actionResult as NotFoundResult;
// Assert.IsNotNull(response);
}
}
//初始化面板数据
public void InitPanelMessage()
{
this.t_bestscore.text = PlayerPrefs.GetInt(Const.BestScore, 0).ToString();
lastStepModel = new StepModel();
b_last.interactable = false;
// 播放音乐
AudioManager._instance.PlayMusic(bgClip);
}
public IActionResult GoToNextStep(StepModel model)
{
UpdateModelInSession(model);
// storing data in TempData because of PRG pattern
_sessionStorage.SetString(SESSION_STEP_NUMBER_KEY, model.StepNumber.ToString());
return(RedirectToAction("NextStep"));
}
public async Task <int> CreateAsync(StepModel model)
{
do
{
model.Code = CodeGenerator.Generate();
}while (DbSet.Any(d => d.Code.Equals(model.Code)));
StepLogic.CreateModel(model);
return(await DbContext.SaveChangesAsync());
}
public static void Run(StepModel model)
{
var toDelete = Array.Empty <IPersistEntity>()
.Concat(model.Instances.OfType <IIfcRelDefinesByProperties>())
.Concat(model.Instances.OfType <IIfcPropertySetDefinition>())
.Concat(model.Instances.OfType <IIfcPropertyAbstraction>())
.ToArray();
model.Delete(toDelete, true);
}
private string CreateTags(StepModel model, string stepFinal)
{
var tags = "";
foreach (var tag in model.Tags)
{
tags += $"[{tag.Replace("@", "")}(\"{stepFinal}\")]{Environment.NewLine}\t\t";
}
return(tags);
}
private void OnPresentStep(NetworkMessage networkMessage)
{
var message = networkMessage.ReadMessage <StepModelNetworkMessage>();
_currentImageTargetIndex = message.ImageTargetIndex;
CurrentStepModel = message.Data;
_currentStepOrder = message.StepOrder;
NetworkServer.SendToAll(NetworkHandles.PresentStep, message);
}
private string CreateMethodBody(StepModel stepModel)
{
var methodBody = "";
foreach (var step in stepModel.Steps)
{
var actualStep = GetStepWithoutTag(ReplaceStepVariables(step, GetParameters(stepModel)));
methodBody += $"{Environment.NewLine}\t\t\t{GetStepTag(step)}($\"{actualStep}\");";
}
return(methodBody);
}
public static Step ToEntity(this StepModel aStepModel)
{
return(new Step()
{
Instructions = aStepModel.Instructions,
SignOffIsRequired = aStepModel.SignOffIsRequired,
StepCategoryId = aStepModel.StepCategory.Id,
StepId = aStepModel.StepId,
StepName = aStepModel.StepName
});
}
private List <string> GetParameters(StepModel model)
{
var variables = new List <string>();
var matches = Regex.Matches(model.StepName, VariablePattern);
foreach (Match match in matches)
{
variables.Add(match.Groups[1].Value);
}
return(variables);
}
public IActionResult CreateStep([FromForm] StepModel data)
{
try
{
Step step = new Step();
int tmp_DesignId;
bool success = Int32.TryParse(data.DesignId.ToString(), out tmp_DesignId);
if (success)
{
step.DesignId = tmp_DesignId;
}
if (!success)
{
step.DesignId = 0; // default
}
step.Title = data.Title;
step.Body = data.Body;
step.Video = data.Video;
step.StepNumber = data.StepNumber;
string path;
if (data.FormFiles != null)
{
foreach (var formFile in data.FormFiles)
{
if (formFile.Length > 0)
{
path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", formFile.FileName);
using (Stream stream = new FileStream(path, FileMode.Create))
{
formFile.CopyTo(stream);
}
byte[] fileToBytes = System.IO.File.ReadAllBytes(path);
FileModel file = PostFilesToDB(step, fileToBytes, formFile.ContentType, formFile.FileName);
_context.Files.Add(file); // IMPORTANT THAT Table gets inserted file row - or else return error: Object reference not set to an instance of an object.
step.Files.Add(file);
}
}
}
_context.Steps.Add(step);
_context.SaveChanges();
return(StatusCode(StatusCodes.Status201Created));
}
catch (Exception e)
{
Console.WriteLine("File POST execption: " + e.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public override async void UpdateModelAsync(int id, MachineModel model)
{
if (model.MachineEvents != null)
{
HashSet <int> indicatorsId = MachineEventLogic.MachineEventIds(id);
foreach (var itemId in indicatorsId)
{
MachineEventsModel data = model.MachineEvents.FirstOrDefault(prop => prop.Id.Equals(itemId));
if (data == null)
{
await MachineEventLogic.DeleteModel(itemId);
}
else
{
MachineEventLogic.UpdateModelAsync(itemId, data);
}
foreach (MachineEventsModel item in model.MachineEvents)
{
if (item.Id == 0)
{
MachineEventLogic.CreateModel(item);
}
}
}
HashSet <int> StepId = MachineEventLogic.MachineEventIds(id);
foreach (var itemId in StepId)
{
StepModel data = model.Steps.FirstOrDefault(prop => prop.Id.Equals(itemId));
if (data == null)
{
await StepLogic.DeleteModel(itemId);
}
else
{
StepLogic.UpdateModelAsync(itemId, data);
}
foreach (StepModel item in model.Steps)
{
if (item.Id == 0)
{
StepLogic.CreateModel(item);
}
}
}
}
EntityExtension.FlagForUpdate(model, IdentityService.Username, UserAgent);
DbSet.Update(model);
}
public void PostTripAdd_Passes()
{
using (IDbContext idtoFakeContext = new IDTOFakeContext())
using (IUnitOfWork unitOfWork = new UnitOfWork(idtoFakeContext))
{
unitOfWork.Repository <Traveler>().Insert(new Traveler {
Id = 1, FirstName = "TestFN", LastName = "TestLN", ObjectState = ObjectState.Added
});
unitOfWork.Save();
var controller = new TripController(idtoFakeContext);
SetupControllerForTests(controller);
TripModel m = new TripModel
{
TravelerId = 1,
Origination = "Neverland",
Destination = "Montana",
TripStartDate = DateTime.Parse("1/2/2014"),
TripEndDate = DateTime.Parse("1/3/2014"),
MobilityFlag = true,
BicycleFlag = true,
PriorityCode = "1"
};
List <StepModel> steps = new List <StepModel>();
StepModel stepmodel = new StepModel();
stepmodel.StartDate = DateTime.Parse("1/1/2014 10:02");
stepmodel.EndDate = DateTime.Parse("1/1/2014 10:40");
stepmodel.FromName = "Quartz Street";
stepmodel.FromProviderId = (int)Providers.COTA;
stepmodel.FromStopCode = "1001";
stepmodel.ModeId = (int)Modes.Bus;
stepmodel.RouteNumber = "039";
stepmodel.Distance = (decimal)12.2;
stepmodel.ToName = "Slate Run Road";
stepmodel.ToProviderId = (int)Providers.COTA;
stepmodel.ToStopCode = "2002";
steps.Add(stepmodel);
m.Steps = steps;
try
{
var actionResult = controller.PostTrip(m);
var response = actionResult as CreatedAtRouteNegotiatedContentResult <TripModel>;
Assert.IsNotNull(response);
var trips = response.Content;
Assert.AreEqual("Neverland", trips.Origination);
}
catch (HttpResponseException ex)
{
Assert.Fail();
}
}
}
public CheckoutViewModel(string baseLink)
{
if (baseLink.LastIndexOf('/') + 1 < baseLink.Length) baseLink = baseLink + "/";
Steps = new StepModel[]{ new StepModel(1, "Xem giỏ hàng", baseLink + "1"),
new StepModel(2, "Khách hàng", baseLink + "2"),
new StepModel(3, "Giao hàng", baseLink + "3"),
new StepModel(4, "Xác nhận", baseLink + "4"),
new StepModel(5, "Hoàn tất", baseLink + "5")
};
CurrentStep = 1;
LastestStep = CacheHelper._CacheHelper.GetLastestCheckoutStep();
ShipmentFees = CacheHelper._CacheHelper.LoadShipmentFee().ToList();
}
public async Task ChangeField(StepModel data)
{
StepModel model = data;
var coordPairs = model.CoordsToMove.Split(';').ToList().Last().Split(',');
var newX = coordPairs[0];
var newY = coordPairs[1];
var changePosDetails = await GameService.ChangeFigurePos(new FigureDTO
{
Id = int.Parse(model.FigureId),
XCoord = int.Parse(newX),
YCoord = int.Parse(newY),
IsSuperFigure = (model.NewSuperFigureStatus == "0") ? false : true
});
var opponent = await UserService.GetUser(new UserDTO { UserName = HttpContextManager.Current.User.Identity.Name });
if (opponent == null)
{
throw new HttpException(404, "Error while searching user in database");
}
var changeTurnQueryDetails = await GameService.ChangeTurnPriority(new GameDTO
{
Id = int.Parse(model.GameId),
LastTurnPlayerId = opponent.Id
});
if (model.FigureIdsToDelete != null)
{
var idStrList = model.FigureIdsToDelete.Split(',').ToList();
var listOfFigureDTOs = new List <FigureDTO>();
foreach (var i in idStrList)
{
listOfFigureDTOs.Add(new FigureDTO {
Id = int.Parse(i)
});
}
var deleteFigureDetails = await GameService.DeleteFigures(listOfFigureDTOs);
if (!deleteFigureDetails.Succedeed)
{
throw new HttpException(404, deleteFigureDetails.ErrorMessage);
}
}
if (!changePosDetails.Succedeed || !changeTurnQueryDetails.Succedeed)
{
throw new HttpException(404, changePosDetails.ErrorMessage + " " + changeTurnQueryDetails.ErrorMessage);
}
}
public async Task <ActionResult <StepModel> > PostStep(StepModel aStep)
{
try
{
var data = await StepService.CreateStep(aStep);
return(Ok(JsonSerializer.Serialize(data)));
}
catch (Exception ex)
{
_logger.LogError("StepsController.PostStep(StepModel aStep) Not able to create step {step}. | Message: {exMessage} | StackTrace: {stackTrace}", JsonSerializer.Serialize(aStep), ex.Message, ex.StackTrace);
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Get Step By Id
/// </summary>
/// <param name="StepId"></param>
/// <returns>Step Model</returns>
public StepModel GetStepById(int StepId)
{
//Call GetStepBYId method of dataLayer which will return Datatable.
DataTable dt = objDLStep.GetStepById(StepId);
StepModel objStepModel = new StepModel();
// if datatable has row than set object parameters
if (dt.Rows.Count > 0)
{
objStepModel = GetDataRowToEntity <StepModel>(dt.Rows[0]);
}
return(objStepModel);
}
public void Step21HeaderTest()
{
using (var s = File.OpenRead("4walls1floorSite.ifc"))
{
var header = StepModel.LoadStep21Header(s);
var schema = header.FileSchema.Schemas.FirstOrDefault();
Assert.IsTrue(header.FileSchema.Schemas.Count == 1);
Assert.AreEqual("IFC2X3", schema);
var name = header.FileName.Name;
Assert.AreEqual("Project Number", name);
var mvd = header.FileDescription.Description.FirstOrDefault();
Assert.AreEqual("ViewDefinition [CoordinationView]", mvd);
}
}
private void UpdateModelInSession(StepModel model)
{
var data = GetRegisteredSteps();
var registeredModel = data
.Where(phase => phase.PhaseNumber == model.PhaseNumber)
.SelectMany(phase => phase.StepModels)
.First(x => x.StepNumber == model.StepNumber);
registeredModel.ElapsedTime = model.ElapsedTime;
registeredModel.SameColor = model.SameColor;
_sessionStorage.SetObjectAsJson(SESSION_STORAGE_RESULTS_KEY, data);
}
public string CreateMethodString(StepModel stepModel)
{
var stepName = stepModel.StepName;
var stepFinal = Regex.Replace(stepName, VariablePattern, "(.*)").Trim();
var method = $@"
{CreateTags(stepModel, stepFinal)}
public void {CreateMethodName(stepFinal)}({CreateParametersString(stepModel)})
{{
{CreateMethodBody(stepModel)}
}}
";
return(method);
}
public static StepModel ToModel(this Step aStep)
{
var result = new StepModel()
{
Instructions = aStep.Instructions,
SignOffIsRequired = aStep.SignOffIsRequired,
StepCategory = aStep.StepCategory.ToModel(),
Inactive = aStep.Inactive,
StepId = aStep.StepId,
StepName = aStep.StepName
};
return(result);
}
private void App_OnStartup(object sender, StartupEventArgs e)
{
IStepModel stepModel = new StepModel();
IController controller = new MainController(stepModel);
ISerieStepUIC currentlyWatching = new Step("Currently Watching", new View(new ViewModel(stepModel, stepModel.CurrentlyWatching, controller)));
ISerieStepUIC completed = new Step("Completed", new View(new ViewModel(stepModel, stepModel.Completed, controller)));
ISerieStepUIC onHold = new Step("On Hold", new View(new ViewModel(stepModel, stepModel.OnHold, controller)));
ISerieStepUIC dropped = new Step("Dropped", new View(new ViewModel(stepModel, stepModel.Dropped, controller)));
ISerieStepUIC planToWatch = new Step("Plan To Watch", new View(new ViewModel(stepModel, stepModel.PlanToWatch, controller)));
IShellViewModel shellViewmodel = new MainShellViewModel(controller, currentlyWatching, completed, onHold, dropped, planToWatch);
var shellView = new ShellView(shellViewmodel);
shellView.Show();
}
private string CreateParametersString(StepModel model)
{
var variables = GetParameters(model);
var parameters = "";
foreach (var variable in variables)
{
parameters += $"string {variable}, ";
}
if (parameters.Length > 0)
{
parameters = parameters.Substring(0, parameters.Length - 2);
}
return(parameters);
}
public void StartCooking(StepModel step, string sessionKey)
{
PubnubAPI pubnub = new PubnubAPI(
"pub-c-40427e1d-7b94-4f2c-bde6-6c93636f2a6f", // PUBLISH_KEY
"sub-c-db9871f4-05e0-11e3-8dc9-02ee2ddab7fe", // SUBSCRIBE_KEY
"sec-c-M2FlN2E1ZTMtNGRkMi00MTg4LTgxYmQtM2E1OWUxMjJlMWMx", // SECRET_KEY
true // SSL_ON?
);
string channel = "startCooking-channel";
System.Threading.Thread.Sleep(step.Time * 60 * 1000);
pubnub.Publish(channel, "Step " + step.Number + " has finished.");
}
