/// <summary>
/// Bootstraps the container.
/// </summary>
private static void BootstrapContainer()
{
_container = new WindsorContainer()
.Install(FromAssembly.This());
ControllerFactory factory = new ControllerFactory(_container.Kernel);
ControllerBuilder.Current.SetControllerFactory(factory);
}
public void PublishMessageIfRuntimePolicyOn(ControllerFactory.CreateController sut, IAlternateMethodContext context, RequestContext requestContext, string controllerName)
{
context.Setup(c => c.Arguments).Returns(new object[] { requestContext, controllerName });
sut.NewImplementation(context);
context.MessageBroker.Verify(mb => mb.Publish(It.IsAny<ControllerFactory.CreateController.Message>()));
}
public void Should_Return_Scheduler_Controller_When_Scheduler_Url_Is_Supplied()
{
var factory = new ControllerFactory();
var handlerType = factory.GetHandlerType("http://localhost/quartz/scheduler");
Assert.That(handlerType, Is.EqualTo(typeof(SchedulerController)));
}
public void Should_Return_Index_Controller_For_Default_Route()
{
var factory = new ControllerFactory();
var handlerType = factory.GetHandlerType("http://localhost/quartz/");
Assert.That(handlerType, Is.EqualTo(typeof(IndexController)));
}
public void Should_Ignore_Extension_When_Determining_Controller()
{
var factory = new ControllerFactory();
var handlerType = factory.GetHandlerType("http://localhost/quartz/index.ashx");
Assert.That(handlerType, Is.EqualTo(typeof(IndexController)));
}
public void ProceedImmediatlyIfRuntimePolicyOff(ControllerFactory.CreateController sut, IAlternateMethodContext context)
{
context.Setup(c => c.RuntimePolicyStrategy).Returns(() => RuntimePolicy.Off);
sut.NewImplementation(context);
context.Verify(c => c.Proceed());
context.MessageBroker.Verify(mb => mb.Publish(It.IsAny<ControllerFactory.CreateController.Message>()), Times.Never());
}
public void ProxyActionInvokerIfControllerFound([Frozen] IProxyFactory proxyFactory, ControllerFactory.CreateController sut, IAlternateMethodContext context, RequestContext requestContext, string controllerName)
{
context.Setup(c => c.ReturnValue).Returns(new DummyController());
context.Setup(c => c.Arguments).Returns(new object[] { requestContext, controllerName });
proxyFactory.Setup(p => p.IsWrapInterfaceEligible<IActionInvoker>(It.IsAny<Type>())).Returns(true);
sut.NewImplementation(context);
proxyFactory.Verify(p => p.WrapInterface(It.IsAny<ControllerActionInvoker>(), It.IsAny<IEnumerable<IAlternateMethod>>(), It.IsAny<IEnumerable<object>>()));
}
public void Setup(IInspectorContext context)
{
var logger = context.Logger;
var originalControllerFactory = ControllerBuilder.Current.GetControllerFactory();
var alternateImplementation = new ControllerFactory(context.ProxyFactory);
IControllerFactory newControllerFactory;
if (alternateImplementation.TryCreate(originalControllerFactory, out newControllerFactory))
{
ControllerBuilder.Current.SetControllerFactory(newControllerFactory);
logger.Debug("Proxied IControllerFactory of type '{0}'.", originalControllerFactory.GetType());
}
}
public void Run_WhenWithId_ThenRepositoryRun()
{
var mock = new Mock <IRepository>();
mock.Setup(a => a.DeleteNode(It.IsAny <int>()));
var factory = new ControllerFactory(mock.Object);
var view = new Mock <IView <Note, IDeleteNoteController> >();
view.Setup(v => v.Info).Returns(new PageInfo());
view.Setup(v => v.Model).Returns(new Note());
var controller = new DeleteNoteController(factory, mock.Object, view.Object);
controller.Run(1);
mock.Verify(m => m.DeleteNode(It.IsAny <int>()), Times.Once());
}
public void FindMaterialsDoesNotFetchAnyMaterialsWithOneAuthorAndZeroMaterials()
{
// setup
var options = new DbContextOptionsBuilder <GTLContext>()
.UseInMemoryDatabase(MethodBase.GetCurrentMethod().Name)
.UseLazyLoadingProxies()
.Options;
var authorOne = new Author {
FirstName = authorFirstName, LastName = authorLastName
};
var authorTwo = new Author {
FirstName = "Gergana", LastName = "Petkova"
};
// action
// add authors to materials
materials.ForEach(material =>
{
material.MaterialAuthors = new List <MaterialAuthor>
{
new MaterialAuthor {
Author = authorTwo, Material = material
}
};
});
using (var context = new GTLContext(options))
{
context.Add(authorOne);
context.AddRange(materials);
context.SaveChanges();
}
// assertion
using (var context = new GTLContext(options))
{
var authorController = ControllerFactory.CreateAuthorController(context);
var fetchedAuthor = context.Authors.FirstOrDefault(a => a.FirstName == authorFirstName);
var fetchedMaterials = authorController.FindMaterials(fetchedAuthor);
Assert.That(fetchedMaterials, Is.Empty.And.Not.Null);
}
}
public List <MyCompany.Data.Objects.vw_SD_T08> Select(
string salesDocumentType,
string salesOrganization,
string distributionChannel,
string division,
string soldTo,
string shipTo,
string purchaseOrderNumber,
string salesDocument,
string invoiceNumber,
string salesDocumentItemCat,
string materialCode,
string keyField1,
string keyField2,
string keyField3,
string rokiDeliveryPlant,
string rokiDelStorageLoc,
string goodsMovementDate,
string lastDeliveryPlant,
string lastDelStorageLoc,
string netValueInDocCurrency,
string sdDocumentCurrency,
string incotermPart1,
string incotermPart2,
string scheduleLineCat,
string scheduleLineDate,
string arrivalTime,
string expr1,
string salesUnit,
string fromTo,
string plantCode,
string addCode,
string vatRate,
string sort,
int maximumRows,
int startRowIndex,
string dataView)
{
PageRequest request = CreateRequest(salesDocumentType, salesOrganization, distributionChannel, division, soldTo, shipTo, purchaseOrderNumber, salesDocument, invoiceNumber, salesDocumentItemCat, materialCode, keyField1, keyField2, keyField3, rokiDeliveryPlant, rokiDelStorageLoc, goodsMovementDate, lastDeliveryPlant, lastDelStorageLoc, netValueInDocCurrency, sdDocumentCurrency, incotermPart1, incotermPart2, scheduleLineCat, scheduleLineDate, arrivalTime, expr1, salesUnit, fromTo, plantCode, addCode, vatRate, sort, maximumRows, startRowIndex);
request.RequiresMetaData = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage("vw_SD_T08", dataView, request);
return(page.ToList <MyCompany.Data.Objects.vw_SD_T08>());
}
public void UpdateManyToManyField(string fieldName, string primaryKeyField, string targetController, string targetForeignKey1, string targetForeignKey2)
{
FieldValue field = SelectFieldValueObject(fieldName);
if (field == null)
{
return;
}
object primaryKey = SelectFieldValue(primaryKeyField);
List <string> oldValues = ValueToList(((string)(field.OldValue)));
List <string> newValues = ValueToList(((string)(field.NewValue)));
if (!(ListsAreEqual(oldValues, newValues)))
{
IDataController controller = ControllerFactory.CreateDataController();
foreach (string s in oldValues)
{
if (!(newValues.Contains(s)))
{
ActionArgs args = new ActionArgs();
args.CommandName = "Delete";
args.LastCommandName = "Select";
args.Values = new FieldValue[] {
new FieldValue(targetForeignKey1, primaryKey, null),
new FieldValue(targetForeignKey2, s, null)
};
controller.Execute(targetController, null, args);
}
}
foreach (string s in newValues)
{
if (!(oldValues.Contains(s)))
{
ActionArgs args = new ActionArgs();
args.CommandName = "Insert";
args.LastCommandName = "New";
args.Values = new FieldValue[] {
new FieldValue(targetForeignKey1, primaryKey),
new FieldValue(targetForeignKey2, s)
};
controller.Execute(targetController, null, args);
}
}
}
}
protected override void AfterSetup()
{
Window.Content = Frame = new ContentControl();
var controllerFactory = new ControllerFactory();
controllerFactory.Register("Sample", () => new SampleController()
{
ActionInvoker = new DefaultActionInvoker()
});
var routes = new ControllerRouteCatalog(controllerFactory);
routes.MapRoute("foobar/{action}", new { controller = "Sample" });
NavigatorFactory = new NavigatorFactory(routes);
Navigator = NavigatorFactory.CreateNavigator(Frame);
}
private void listControllerView_SelectedIndexChanged(object sender, EventArgs e)
{
// 建立表格view项目类
ListViewItem itemView = listControllerView.SelectedItems[0];
// 判断项目视图
if (itemView.Tag != null)
{
ControllerInfo controllerInfo = (ControllerInfo)itemView.Tag;
Controller ctrl = ControllerFactory.CreateFrom(controllerInfo);
ctrl.Logon(UserInfo.DefaultUser);
// 指明 item 归属的控件
ListViewItem item = new ListViewItem(ctrl.RobotWare.ToString() + "" + ctrl.State.ToString() + "" + ctrl.OperatingMode.ToString());
this.listOutput.Items.Add(item);
}
}
public DataAppCore(string dbpath = null)
{
if (string.IsNullOrEmpty(dbpath) == false)
{
this.controllerFactory = new ControllerFactory(dbpath);
}
else
{
this.controllerFactory = new ControllerFactory();
}
this.UserController = controllerFactory.CreateIUserController();
this.CheckController = controllerFactory.CreateCheckController();
this.ExpenseController = controllerFactory.CreateExpenseController();
this.ProjectController = controllerFactory.CreateProjectController();
Seed();
}
public void CreateController()
{
Console.WriteLine("ControllerFactory Start creating objects");
IController ic = ControllerFactory.CreateController();
if (ic != null)
{
Console.WriteLine("Create object success！");
}
else
{
Assert.Fail("Failed to create an object, the return value is null!");
}
bool isMySqlCon = ic is MySqlController;
Console.WriteLine("Whether to MySqlController objects：：" + isMySqlCon);
}
public void AddNote_WhenCall_ThenRepositoryRun()
{
var mock = new Mock <IRepository>();
mock.Setup(a => a.AddNote(It.IsAny <Note>()));
var factory = new ControllerFactory(mock.Object);
var view = new Mock <IView <Note, ICreateNoteController> >();
view.Setup(v => v.Info).Returns(new PageInfo());
view.Setup(v => v.Model).Returns(new Note());
var controller = new CreateNoteController(factory, mock.Object, view.Object);
controller.AddNote(new Note {
Title = "Test"
});
mock.Verify(m => m.AddNote(It.IsAny <Note>()), Times.Once());
}
public void Run_ThenRepositoryGetNotesCall()
{
var mock = new Mock <IRepository>();
mock.Setup(r => r.GetNotes());
var factory = new ControllerFactory(mock.Object);
var view = new Mock <IView <List <Note>, IController> >();
view.Setup(v => v.Info).Returns(new PageInfo());
view.Setup(v => v.Model).Returns(new List <Note> {
new Note()
});
view.Setup(v => v.Render());
var controller = new ViewAllController(factory, mock.Object, view.Object);
controller.Run();
mock.Verify(v => v.GetNotes(), Times.Once());
}
public void CreateCreatesCorrectAuthorInstance()
{
// setup
var options = new DbContextOptionsBuilder <GTLContext>()
.UseInMemoryDatabase(MethodBase.GetCurrentMethod().Name)
.Options;
using var context = new GTLContext(options);
var authorController = ControllerFactory.CreateAuthorController(context);
// action
var author = authorController.Create(authorFirstName, authorLastName);
// assertion
Assert.That(author, Has
.Property(nameof(Author.FirstName)).EqualTo(authorFirstName).And
.Property(nameof(Author.LastName)).EqualTo(authorLastName));
}
public void ProcessRequest(HttpContext context)
{
string controller = context.Request["controller"];
ControllerBase cb = ControllerFactory.Create(controller);
string json = "";
if (cb == null)
{
json = JsonResultHelper.GetErrorJson("controler【" + controller + "】不存在！");
}
else
{
json = cb.ajax(context.Request);
}
context.Response.ContentType = "application/json";
context.Response.Write(json);
}
protected object GetRunners(ControllerFactory controllerFactory)
{
var controller = controllerFactory.AppController;
var runners = controller.GetRunners();
var entrants = runners.OrderBy(r => r.Number).Select(r => new
{
r.Number,
r.FirstName,
r.LastName,
r.DateOfBirth,
agegroup = AgeGroup.GetAgeGroup(controller.CurrentRace.Date, r.DateOfBirth, r.Gender).ToString(),
r.Club,
r.Team,
r.Urn,
}).Cast <object>().ToList();
return(new { entrants = entrants });
}
public void CreateThrowsAnArgumentExceptionOnNonExistingMaterialSubject()
{
// setup
var bookType = new MaterialType {
Type = "Book"
};
var programmingSubject = new MaterialSubject {
SubjectName = "Programming"
};
var author = new Author {
FirstName = "Nikola", LastName = "Velichkov"
};
var options = new DbContextOptionsBuilder <GTLContext>()
.UseInMemoryDatabase(MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new GTLContext(options))
{
context.Add(bookType);
context.Add(author);
context.SaveChanges();
}
using (var context = new GTLContext(options))
{
var controller = ControllerFactory.CreateMaterialController(context);
Assert.Throws <ArgumentException>(() =>
controller.Create(
_isbn,
_title,
_language,
_lendable,
_description,
bookType,
new List <MaterialSubject> {
programmingSubject
},
new List <Author> {
author
}
));
}
}
public void CreateCreatesCorrectly()
{
// setup
var options = new DbContextOptionsBuilder <GTLContext>()
.UseInMemoryDatabase(MethodBase.GetCurrentMethod().Name)
.Options;
int memberId;
int volumeId;
using (var context = new GTLContext(options))
{
context.Add(_member);
context.Add(_volume);
context.SaveChanges();
memberId = _member.MemberId;
volumeId = _volume.VolumeId;
}
// action
using (var context = new GTLContext(options))
{
var member = context.Members.Find(memberId);
var volume = context.Volumes.Find(volumeId);
var controller = ControllerFactory.CreateLoanController(context);
var loan = controller.Create(member, volume);
// assertion
var today = DateTime.Today;
var dueDate = DateTime.Today.AddDays(LoanController.LendingPeriod);
Assert.That(loan, Has
.Property(nameof(Loan.Member)).Not.Null.And
.Property(nameof(Loan.Volume)).Not.Null.And
.Property(nameof(Loan.LoanDate)).EqualTo(today).And
.Property(nameof(Loan.DueDate)).EqualTo(dueDate).And
.Property(nameof(Loan.ReturnedDate)).Null.And
.Property(nameof(Loan.Extensions)).EqualTo(0)
);
}
}
public string CreateInitialFieldMap(string fileName, string controller, string view)
{
// retreive metadata
PageRequest request = new PageRequest();
request.Controller = controller;
request.View = view;
request.RequiresMetaData = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage(controller, view, request);
// create initial map
StringBuilder sb = new StringBuilder();
OleDbDataReader reader = OpenRead(fileName, "*");
try
{
ImportMapDictionary map = new ImportMapDictionary();
ImportLookupDictionary lookups = new ImportLookupDictionary();
EnumerateFields(reader, page, map, lookups, null);
for (int i = 0; (i < reader.FieldCount); i++)
{
sb.AppendFormat("{0}=", reader.GetName(i));
DataField field = null;
if (map.TryGetValue(i, out field))
{
string fieldName = field.Name;
foreach (DataField lookupField in lookups.Values)
{
if (lookupField.AliasName == field.Name)
{
fieldName = lookupField.Name;
break;
}
}
sb.Append(fieldName);
}
sb.AppendLine();
}
}
finally
{
reader.Close();
}
return(sb.ToString());
}
private async void RequestReceived(BattleSession session, BinaryRequestInfo requestInfo)
{
int offset = 0;
var sizeHeader = sizeof(MessageType);
var intSize = sizeof(int);
while (offset < requestInfo.Body.Length)
{
BaseController controller = null;
MessageType msgType = MessageType.None;
byte[] body = null;
try
{
var byteArrayHeader = requestInfo.Body.CloneRange(offset, sizeHeader);
var byteArrayBodyLength = requestInfo.Body.CloneRange(offset + sizeHeader, intSize);
var bodyLength = BitConverter.ToInt32(byteArrayBodyLength, 0);
body = requestInfo.Body.CloneRange(offset + intSize + sizeHeader, bodyLength);
offset += (sizeHeader + intSize + bodyLength);
msgType = (MessageType)BitConverter.ToInt32(byteArrayHeader, 0);
}
catch (Exception)
{
var msg = $"{msgType.ToString()}_{ (requestInfo.Body?.Length ?? 0).ToString()}_{session.SocketSession.RemoteEndPoint.ToString()}";
Console.WriteLine(msg);
return;
}
BaseProtocol proto = null;
proto = ProtocolFactory.DeserializeProtocol(msgType, body);
try
{
controller = ControllerFactory.CreateController(msgType);
await controller.DoPipeline(session, proto);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
}
private void ActivateView(ActivateViewMessage message)
{
var viewName = message.ViewName;
if (_views.ContainsKey(viewName))
{
var view = (Control)_views[viewName];
if (Controls.Contains(view))
{
view.BringToFront();
ActiveView = _views[viewName];
UpdateRibbonItems();
}
}
else
{
var viewPath = BasePath + "/DockPanels/" + viewName;
if (!AddInTree.ExistsTreeNode(viewPath))
{
return;
}
var viewDescriptor = (DockPanelDescriptor)AddInTree.BuildItem(viewPath, null);
if (viewDescriptor == null)
{
throw new Exception(string.Format("{0} doesn't exist in addin file, please check it.", viewPath));
}
var controller = ControllerFactory.CreateController(viewDescriptor.ControllerId);
this._controllers[viewDescriptor.ControllerId] = controller;
var result = new ActionInvoker().Invoke(controller, null, message.Parameters) as IPartialViewResult;
if (result != null)
{
result.View.ViewName = viewDescriptor.Codon.Id;
AddView(result.View);
var view = (Control)result.View;
view.Dock = DockStyle.Fill;
this.Controls.Add(view);
view.BringToFront();
ActiveView = result.View;
InitObjectWidget(controller);
UpdateRibbonItems();
}
}
}
// 0) path => Blog.Admin
// 1) path => Blog
// 2) path => ""
private static String addLayoutPrivate(String path, String actionContent, MvcContext ctx, Boolean isLastLayout)
{
ControllerBase controller = ControllerFactory.FindLayoutController(path, ctx);
if (controller == null)
{
return(actionContent);
}
ctx.controller.utils.addHidedLayouts(controller); // 将controller中提到需要隐藏的控制器隐藏
if (ctx.controller.utils.isHided(controller.GetType()))
{
return(actionContent);
}
// 检查缓存
ActionCacheChecker ci = ActionCacheChecker.InitLayout(ctx, controller);
Object cacheContent = ci.GetCache();
if (cacheContent != null)
{
logger.Info("load from nsLayoutCache=" + ci.CacheKey);
return(HtmlCombiner.combinePage(cacheContent.ToString(), actionContent));
}
controller.utils.switchViewToLayout();
ActionRunner.runLayoutAction(ctx, controller, controller.Layout);
if (ctx.utils.isEnd())
{
return(ctx.utils.getCurrentOutputString());
}
String actionResult = controller.utils.getActionResult();
if (ci.IsActionCache)
{
ci.AddCache(actionResult);
}
return(HtmlCombiner.combinePage(actionResult, actionContent));
}
public void LoadViews(ActionParameters parameters)
{
var dockPath = BasePath + "/DockPanels";
if (AddInTree.ExistsTreeNode(dockPath))
{
LoadMainView(dockPath, parameters);
var descriptors = AddInTree.BuildItems <object>(dockPath, this, false).OfType <DockPanelDescriptor>().ToList();
foreach (var descriptor in descriptors)
{
bool isLazy = false;
bool.TryParse(descriptor.Codon.Properties["lazy"], out isLazy);
if (isLazy)
{
continue;
}
var controller = ControllerFactory.CreateController(descriptor.ControllerId);
controller.WorkSpaceID = this.ID;
controller.Context = this._workspaceContext;
_controllers[descriptor.ControllerId] = controller;
InitObjectWidget(controller);
var result = new ActionInvoker().Invoke(controller, null, parameters) as IPartialViewResult;
if (result != null)
{
result.View.ViewName = descriptor.Codon.Id;
AddView(result.View);
CreateDockPanel(descriptor, result.View);
}
}
}
else
{
throw new Exception("Config path not found:" + dockPath);
}
WorkSpaceTextLoader txtLoader = new WorkSpaceTextLoader();
string mainText = string.Empty;
Title = txtLoader.GetListWorkSpaceTitle(ObjectName, out mainText);
this.UpdateRibbonItems();
}
/// <summary>
/// 运行某action，id由ctx.route.id自动注入。
/// 如果action有参数，请预先设置 ctx.route.id；
/// 如果方法中涉及到owner，请预先设置 ctx.owner；
/// controller是经过依赖注入处理的。
/// 注意1：未处理action过滤器批注。
/// 注意2：因为通过controller的字符串运行，所以经过反射调用。
/// </summary>
/// <param name="ctx">提供 ctx.route.id 和 ctx.owner 等可能需要的参数</param>
/// <param name="controllerFullName">控制器的完整类型type的full name</param>
/// <param name="actionName"></param>
/// <returns></returns>
public static String Run(MvcContext ctx, String controllerFullName, String actionName)
{
if (controllerFullName == null)
{
throw new NullReferenceException();
}
ControllerBase targetController = ControllerFactory.FindController(controllerFullName, ctx);
if (targetController == null)
{
throw new Exception("controller not found");
}
targetController.view(actionName);
targetController.utils.runAction(actionName);
return(targetController.utils.getActionResult());
}
public static IMvcBuilder AddControllers(this IMvcBuilder builder, ILoggerFactory logFactory,
params Assembly[] assemblies)
{
// Generate controllers for types registered in the assemblies
var controllers = ControllerFactory.Create(logFactory, assemblies).ToList();
var controllerTypes = controllers.SelectMany(x => x.controllerType);
var serviceTypes = ControllerFactory.GetServiceTypes(assemblies).ToList();
// Enable the services to configure themselves by registering requires service dependencies
controllers.ForEach(x => x.serviceMetadata?.ConfigureServices(builder.Services));
// Register services to DI container
serviceTypes.ForEach(x => builder.Services.AddTransient(x));
builder.ConfigureApplicationPartManager(apm =>
apm.FeatureProviders.Add(new GenericControllerFeatureProvider(controllerTypes)));
return(builder);
}
public void CreateWithNonExistingDataThrowsArgumentException()
{
var methodName = MethodBase.GetCurrentMethod().Name;
var options = new DbContextOptionsBuilder <GTLContext>().UseInMemoryDatabase(methodName).Options;
// There is no material and address with the following IDs in the DB
var materialId = 1;
var homeLocationId = 1;
var currentLocationId = 1;
using (var context = new GTLContext(options))
{
var volumeController = ControllerFactory.CreateVolumeController(context);
// Since there is no address and material in the DB, creating a volume with those
// references should throw and exception
Assert.Throws <ArgumentException>(() => volumeController.Create(materialId, homeLocationId, currentLocationId));
}
}
public void CreateCreatesCorrectly()
{
var methodName = MethodBase.GetCurrentMethod().Name;
var options = new DbContextOptionsBuilder <GTLContext>().UseInMemoryDatabase(methodName).Options;
// setup
using (var context = new GTLContext(options))
{
var zip = new ZipCode {
City = "Aalborg", Code = 9000
};
// zip has to be saved in db in order for the address to be created
context.Add(zip);
context.SaveChanges();
var homeAddress = new Address {
Street = "Main road 4", AdditionalInfo = "4.floor, 10", Zip = zip
};
var currentAddress = new Address {
Street = "Library road 5", AdditionalInfo = "1.floor", Zip = zip
};
var material = new Material {
Isbn = "1234321", Title = "Mat title", Description = "A description", Language = "English", Lendable = true
};
context.Add(homeAddress);
context.Add(currentAddress);
context.Add(material);
context.SaveChanges();
var volumeController = ControllerFactory.CreateVolumeController(context);
var createdVolume = volumeController.Create(materialId: material.MaterialId, homeLocationId: homeAddress.AddressId, currentLocationId: currentAddress.AddressId);
Assert.Multiple(() =>
{
Assert.AreEqual(createdVolume.Material.MaterialId, material.MaterialId);
Assert.AreEqual(createdVolume.HomeLocation.AddressId, homeAddress.AddressId);
Assert.AreEqual(createdVolume.CurrentLocation.AddressId, currentAddress.AddressId);
});
}
}
protected virtual void AppendDeepFilter(string hint, ViewPage page, DbCommand command, StringBuilder sb, string filter)
{
string[] hintInfo = hint.Split(new char[] {
'.'
});
int index = filter.IndexOf(":");
string fieldData = filter.Substring((index + 1));
for (int i = 0; (i < NegativeFilterOperations.Length); i++)
{
string negativeOperation = NegativeFilterOperations[i];
if (fieldData.StartsWith(negativeOperation))
{
sb.Append("not ");
filter = (filter.Substring(0, (index + 1))
+ (ReverseNegativeFilterOperations[i] + filter.Substring((index
+ (1 + negativeOperation.Length)))));
break;
}
}
sb.Append("exists(");
PageRequest r = new PageRequest();
r.Controller = hintInfo[0];
r.View = hintInfo[1];
r.Filter = new string[] {
filter
};
DataControllerBase controller = ((DataControllerBase)(ControllerFactory.CreateDataController()));
foreach (DataField field in page.Fields)
{
if (field.IsPrimaryKey)
{
r.InnerJoinPrimaryKey = ("resultset__." + field.Name);
r.InnerJoinForeignKey = hintInfo[2];
break;
}
}
controller.ConfigureSelectExistingCommand(r, command, sb);
sb.Append(")");
}
public void Setup()
{
//Arrange
_fakeDisplay = Substitute.For <IDisplay>();
_fakeTrackDataFilter = Substitute.For <ITrackDataFilter>();
_fakeFlightCalculator = Substitute.For <IFlightCalculator>();
_fakeCollisionDetector = Substitute.For <ICollisionDetector>();
_fakeDecoder = Substitute.For <IDecoder>();
_fakeReceiver = Substitute.For <ITransponderReceiver>();
_fakeEventArgs = new RawTransponderDataEventArgs(new List <string>());
_fakeTrackData = new List <TrackData>();
_fakeFilteredData = new List <TrackData>();
_emptyFlightData = new Dictionary <string, FlightData>();
_fakeFlightData = new Dictionary <string, FlightData>();
_fakeCalculatedData = new Dictionary <string, FlightData>();
_fakeSeperationData = new Tuple <List <string>, List <string> >(new List <string>(), new List <string>());
//Fake decoder should return fake Trackdata when called with fakeEventArgs
_fakeDecoder.Decode(_fakeEventArgs).Returns(_fakeTrackData);
//Filter returns _fakeFilteredData
_fakeTrackDataFilter.Filter(_fakeTrackData).Returns(_fakeFilteredData);
//FlightCalculator returns _fakeFlightData
_fakeFlightCalculator.Calculate(Arg.Any <Dictionary <string, FlightData> >(), Arg.Any <List <TrackData> >())
.Returns(_fakeCalculatedData);
//Seperation detector returns _fakeSeperationData
_fakeCollisionDetector.SeperationCheck(Arg.Any <List <TrackData> >())
.Returns(_fakeSeperationData);
ControllerFactory fakeFactory = new ControllerFactory(
_fakeDecoder,
_fakeTrackDataFilter,
_fakeCollisionDetector,
_fakeDisplay,
_fakeReceiver,
_fakeFlightCalculator);
_uut = new ATMController(fakeFactory);
}
public void InsertMemberIntoDatabase()
{
MethodBase method = MethodBase.GetCurrentMethod();
DbContextOptions <GTLContext> options = new DbContextOptionsBuilder <GTLContext>()
.UseInMemoryDatabase(method.Name).EnableSensitiveDataLogging(true)
.Options;
using (var context = new GTLContext(options))
{
IMemberController mController = ControllerFactory.CreateMemberController(context);
//Currently only inserting for the first method calling it.
InsertDummyData(context);
var member = mController.Create(ssn, fName, lName, homeAddres, campusAddress, zip, homeAddressAdditionalInfo, mTypes);
mController.Insert(member);
Assert.That(member, Has.Property("FName").EqualTo(fName).And.Property("LName").EqualTo(lName)
);
}
}
private void ApplicationStartup(object sender, StartupEventArgs e)
{
var main = new MainView();
RootVisual = main;
var controllerFactory = new ControllerFactory();
controllerFactory.Register("Home", () => new HomeController());
var routes = new RouteCollection();
routes.Register("Patient", "Patients/{patientId}", new ControllerRouteHandler(controllerFactory)).Defaults(controller => "Home", action => "Patient");
routes.Register("Default", "{controller}/{action}", new ControllerRouteHandler(controllerFactory));
var navigator = new Navigator(routes);
navigator.RegisterFrame(main.MainFrame);
navigator.Navigate(controller => "Home", action => "Index");
}
public async Task GetTodoItemById_HandlerThrows_Rethrows()
{
var factory = new ControllerFactory();
var mockHandler = Mock.Of <IHandler>();
Mock.Get(mockHandler).Setup(
x => x.HandleQuery <GetTodoItemByIdQuery, GetTodoItemByIdQueryResult>(
It.IsAny <GetTodoItemByIdQuery>()))
.ThrowsAsync(new Exception());
factory.Services.Replace(
ServiceDescriptor.Scoped(factory => mockHandler));
var controller = factory.Create <TodoController>();
Func <Task> act = async() => await controller.GetTodoItemById(1, 1);
await act.Should().ThrowAsync <Exception>();
}
protected virtual string GenerateOutputFileName(ActionArgs args, string outputFileName)
{
args.CommandArgument = args.CommandName;
args.CommandName = "FileName";
var values = new List <FieldValue>();
values.Add(new FieldValue("FileName", outputFileName));
args.Values = values.ToArray();
var result = ControllerFactory.CreateDataController().Execute(args.Controller, args.View, args);
foreach (var v in result.Values)
{
if (v.Name == "FileName")
{
outputFileName = Convert.ToString(v.Value);
break;
}
}
return(outputFileName);
}
public ApiModule( ControllerFactory controllerFactory )
: base("/api")
{
Get["/raceinfo"] = parameters =>
{
try
{
return Response.AsJson( GetRaceInfo( controllerFactory ) );
}
catch ( Exception ex )
{
return Response.AsJson(ex.Message, HttpStatusCode.InternalServerError);
}
};
Get["/runner"] = parameters =>
{
var number = Request.Query["number"];
var runner = GetRunner( controllerFactory, number );
var statusCode = HttpStatusCode.OK;
if ( runner == null )
{
statusCode = HttpStatusCode.InternalServerError;
}
return Response.AsJson( new {runner = runner}, statusCode);
};
Get["/runners"] = parameters => Response.AsJson( GetRunners( controllerFactory ) );
Get["/results"] = parameters =>
{
try
{
var resultsToList = 0;
int.TryParse( Request.Query["resultsToList"], out resultsToList );
if ( resultsToList == 0 )
{
resultsToList = int.MaxValue;
}
return Response.AsJson( GetResults( controllerFactory, resultsToList ) );
}
catch ( Exception ex )
{
return HandleException(ex);
}
};
Get["/result"] = parameters =>
{
var position = Request.Query["position"];
var raceResult = GetResult(controllerFactory, position);
var statusCode = HttpStatusCode.OK;
if (raceResult == null)
{
statusCode = HttpStatusCode.InternalServerError;
}
return Response.AsJson(new { raceResult = raceResult }, statusCode);
};
Post["/updateresult"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var newResult = this.Bind<NewResult>();
var result = new Result()
{
Position = newResult.Position,
RaceNumber = newResult.RaceNumber,
Time = new TimeSpan( newResult.Hours, newResult.Minutes, newResult.Seconds ),
};
appController.UpdateResult( result );
return Response.AsJson(message, statusCode);
}
catch (Exception ex)
{
return HandleException(ex);
}
};
Post["/addresult"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var newResult = this.Bind<NewResult>();
var result = new Result()
{
Position = newResult.Position,
RaceNumber = newResult.RaceNumber,
Time = new TimeSpan( newResult.Hours, newResult.Minutes, newResult.Seconds ),
};
appController.InsertResult( result );
return Response.AsJson( message, statusCode );
}
catch ( Exception ex )
{
return HandleException( ex );
}
};
Post["/deleteresult"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var deleteResult = this.Bind<DeleteResult>();
// Neither selected
if ( !deleteResult.DeleteNumber && !deleteResult.DeleteTime )
{
throw new Exception("Nothing selected to delete...");
}
// Both selected
if ( deleteResult.DeleteNumber && deleteResult.DeleteTime )
{
appController.DeleteResultAtPosition( deleteResult.Position );
}
// Delete just the number - shifting numbers down
else if ( deleteResult.DeleteNumber && !deleteResult.DeleteTime )
{
appController.DeleteRunnerNumberShiftDown(deleteResult.Position);
}
// Delete the result time, shifting times down
else if (!deleteResult.DeleteNumber && deleteResult.DeleteTime)
{
appController.DeleteTimeShiftDown(deleteResult.Position);
}
return Response.AsJson(message, statusCode);
}
catch (Exception ex)
{
return HandleException( ex );
}
};
Get["/finishers"] = parameters => Response.AsJson( GetFinishers( controllerFactory ) );
Get["/winners"] = parameters => Response.AsJson( GetWinners( controllerFactory ) );
Get["/teams"] = parameters => Response.AsJson( GetTeams( controllerFactory ) );
Post["/addrunner"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var newRunner = this.Bind<NewRunner>();
// Check fields
CheckField( newRunner.FirstName, "First Name" );
CheckField( newRunner.LastName, "Last Name" );
CheckField( newRunner.Gender, "Gender" );
CheckField( newRunner.DoB, "DoB" );
int number;
if ( !int.TryParse( newRunner.Number, out number ) )
{
throw new Exception( "Race number format is incorrect." );
}
var runners = appController.GetRunners();
if ( runners.Any( r => r.Number == number ) )
{
throw new Exception("A runner with this number already exists.");
}
var runner = new Runner
{
FirstName = newRunner.FirstName,
LastName = newRunner.LastName,
Gender = ( newRunner.Gender == "F" ) ? GenderEnum.Female : GenderEnum.Male,
DateOfBirth = DateTime.Parse( newRunner.DoB ),
Email = newRunner.Email,
Number = number,
Club = newRunner.Club,
Team = newRunner.Team,
Urn = newRunner.Urn,
};
runner.ToUpperCase();
var db = appController.DbService;
if ( !db.TestDuplicate( runner ) )
{
db.AddRunner( runner );
message = string.Format( "'{0}' added to database OK.", runner.ToString() );
}
else
{
throw new Exception(string.Format("'{0}' with this DoB already exists in database.", runner.ToString()));
}
return Response.AsJson( message, statusCode );
}
catch ( Exception ex )
{
return HandleException(ex);
}
};
Post["/updaterunner"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var newRunner = this.Bind<NewRunner>();
// Check fields
CheckField( newRunner.FirstName, "First Name" );
CheckField( newRunner.LastName, "Last Name" );
CheckField( newRunner.Gender, "Gender" );
CheckField( newRunner.DoB, "DoB" );
int number;
if ( !int.TryParse( newRunner.Number, out number ) )
{
throw new Exception( "Race number format is incorrect." );
}
int newNumber = 0;
var haveNewNumber = false;
if ( !string.IsNullOrEmpty( newRunner.NewNumber ) )
{
if ( !int.TryParse( newRunner.NewNumber, out newNumber ) )
{
throw new Exception( "The format of the new race number is not correct." );
}
haveNewNumber = true;
}
// Update
var runner = new Runner
{
Number = number,
FirstName = newRunner.FirstName,
LastName = newRunner.LastName,
Gender = ( newRunner.Gender == "Female" ) ? GenderEnum.Female : GenderEnum.Male,
DateOfBirth = DateTime.Parse( newRunner.DoB ),
Email = newRunner.Email,
Club = newRunner.Club,
Team = newRunner.Team,
Urn = newRunner.Urn,
HaveNewNumber = haveNewNumber,
NewNumber = newNumber,
};
runner.ToUpperCase();
appController.DbService.UpdateRunner( runner );
return Response.AsJson( message, statusCode );
}
catch ( Exception ex )
{
return HandleException( ex );
}
};
Post["/deleterunner"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var number = this.Bind<RunnerNumber>();
appController.DbService.DeleteRunner(number.Number);
Trace.WriteLineIf( AppController.traceSwitch.TraceInfo,
string.Format( "Runner with number {0} deleted.", number.Number ) );
return Response.AsJson( message, statusCode );
}
catch ( Exception ex )
{
return HandleException(ex);
}
};
Post["/addfinishposition"] = ( x ) =>
{
var appController = controllerFactory.AppController;
var message = "";
var statusCode = HttpStatusCode.OK;
try
{
var posResult = this.Bind<PositionResult>();
if ( !appController.IsClockRunning )
{
throw new Exception( "Race is not in progress (clock not running)." );
}
if ( posResult.Position <= 0 )
{
message = "Race number must be > 0";
statusCode = HttpStatusCode.BadRequest;
}
else
{
appController.AddResultRunnerNumber( posResult.Position );
Trace.WriteLineIf( AppController.traceSwitch.TraceInfo, "Runner number added: " + posResult.Position );
}
return Response.AsJson( message, statusCode );
}
catch ( Exception ex )
{
return HandleException( ex );
}
};
}
public void SetMethodToImplement(ControllerFactory.CreateController sut)
{
var result = sut.MethodToImplement;
Assert.Equal("CreateController", result.Name);
}
private object GetTeams(ControllerFactory controllerFactory)
{
var teams = controllerFactory.AppController.GetTeamResults();
return new { teams = teams };
}
protected object GetFinishers(ControllerFactory controllerFactory)
{
var finishers = controllerFactory.AppController.GetFinishers();
return new { finishers = finishers };
}
protected object GetRunners(ControllerFactory controllerFactory)
{
var controller = controllerFactory.AppController;
var runners = controller.GetRunners();
var entrants = runners.OrderBy( r => r.Number ).Select( r => new
{
r.Number,
r.FirstName,
r.LastName,
r.DateOfBirth,
agegroup = AgeGroup.GetAgeGroup( controller.CurrentRace.Date, r.DateOfBirth, r.Gender ).ToString(),
r.Club,
r.Team,
r.Urn,
} ).Cast<object>().ToList();
return new {entrants = entrants};
}
protected object GetRaceInfo( ControllerFactory controllerFactory )
{
var race = controllerFactory.AppController.CurrentRace;
return new
{
name = race.Name,
description = race.Description,
date = race.Date,
distance = race.Distance,
};
}
protected object GetResult(ControllerFactory controllerFactory, int position )
{
var result = controllerFactory.AppController.GetResults().FirstOrDefault( r => r.Position == position);
if ( result == null ) return null;
return new
{
position = position,
time = result.Time,
result.RaceNumber,
};
}
private object GetWinners( ControllerFactory controllerFactory )
{
var winners = controllerFactory.AppController.GetWinners();
return new { winners = winners };
}
protected object GetRunner(ControllerFactory controllerFactory, int runnerNumber)
{
var controller = controllerFactory.AppController;
var runner = controller.GetRunners().FirstOrDefault( r => r.Number == runnerNumber );
if ( runner == null ) return null;
return new
{
runner.Number,
runner.FirstName,
runner.LastName,
runner.Email,
gender = runner.Gender.ToString(),
dob = runner.DateOfBirth.ToString("yyyy/MM/dd"),
runner.Club,
runner.Team,
runner.Urn,
};
}
/// <summary>
/// Returns the list of finishing times and positions
/// </summary>
protected object GetResults(ControllerFactory controllerFactory, int number)
{
var results = controllerFactory.AppController.GetResults();
var raceResults = results.OrderByDescending(r => r.Position).Take( number ).Select(r => new
{
r.Position,
Time = r.Time.TotalMilliseconds,
r.RaceNumber,
r.DubiousResult,
reason = r.GetDubiousResultReason(),
}).Cast<object>().ToList();
return new { raceResults = raceResults };
}
public void ReturnAllAlternateMethods(ControllerFactory sut)
{
Assert.NotEmpty(sut.AllMethods);
}
public HelloWorldHandler()
{
_controllerFactory = new ControllerFactory();
_accountController = _controllerFactory.CreateAccountController();
}
