/// <summary>
/// The start method of the application.
/// </summary>
protected void Application_Start()
{
// Perform any tasks required before composition.
PreCompose();
// Create the composer used for composition.
Composer = CreateComposer();
// Compose the application.
Compose();
// Set the controller factory.
ControllerBuilder.Current.SetControllerFactory(ControllerFactory);
//Register custom Virtual Path Provider which reads embedded views and resources
HostingEnvironment.RegisterVirtualPathProvider(new AssemblyResourceProvider());
string[] viewLocations = GetPluginsViewLocations();
// Set the view engine that supports imported areas.
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new PluginViewEngine(viewLocations));
// Initialises the application.
Initialise();
// Register MVC routes.
RegisterRoutes();
}
public static void Main(string[] args)
{
MainViewModel mainViewModel = Composer.GetComposedMainViewModel(new ConsoleFilePathGetter());
MainView mainView = new MainView(mainViewModel);
mainView.List();
Console.ReadLine();
}
public void AddComposer(ComposerInputModel user)
{
var composer = new Composer
{
FirstName = user.FirstName,
LastName = user.LastName
};
_db.Composers.Add(composer);
_db.SaveChanges();
}
/// <summary>
/// Builds this instance.
/// </summary>
/// <returns>Serilog.ILogger.</returns>
public LoggerConfiguration Configure()
{
Composer.Register(
Scanner,
this,
typeof(ISerilogConvention),
typeof(SerilogConventionDelegate)
);
return(LoggerConfiguration);
}
private void ChangeDescription()
{
var composer = new Composer {
Title = "Description", Text = ViewModel.Description
};
composer.NewComment(this, (text) => {
ViewModel.Description = text;
composer.CloseComposer();
});
}
public void SingleNest()
{
Composer composer = new Composer();
Object[] objects = { new Middle(), new Bottom(), new Bottom() };
Middle middle = composer.Compose <Middle>(objects);
Assert.AreEqual(objects[0], middle);
Assert.AreEqual(objects[1], middle.Bottom);
Assert.AreEqual(objects[2], middle.Bottom2);
}
public void it_should_serialize_result_to_header()
{
object[] arguments = { 1, 2 };
int expected = 3;
var result = Composer.ComposeResponse(CreateRequestMapping("Multiply", arguments), expected, arguments);
result.Should().BeOfType <StringResponseInfo>();
Converter.Verify(instance => instance.ConvertFrom(expected, It.IsAny <IResponseInfo>()), Times.Never);
result.Headers.Should().ContainKey("Pragma").WhichValue.Should().Be(expected.ToString());
}
public void DoubleNest()
{
Composer composer = new Composer();
Object[] objects = { new Top(), new Middle(), new Bottom() };
Top top = composer.Compose <Top>(objects);
Assert.AreEqual(objects[0], top);
Assert.AreEqual(objects[1], top.Middle);
Assert.AreEqual(objects[2], top.Middle.Bottom);
}
void InitializeCardNotes()
{
buttonClickedSound = Resources.Load <AudioClip>("Music/button_clicked_sound");
cardNotes = Resources.LoadAll <AudioClip>("Music/CardNotes");
composer = new Composer(cardNotes.Length);
foreach (AudioClip ac in cardNotes)
{
composer.AddNote(ac.name);
}
}
public async Task <IActionResult> Create([Bind("ID,FullName,Nationality,BirthDate")] Composer composer)
{
if (ModelState.IsValid)
{
_context.Add(composer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(composer));
}
public async Task <IActionResult> Create([Bind("ComposerId,ComposerName,ComposerSurname,ComposerEmail,ComposerGrade")] Composer composer)
{
if (ModelState.IsValid)
{
_context.Add(composer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(composer));
}
public void UpdateCompser(string id, Composer composer)
{
ObjectId mongoId = new ObjectId(id);
FilterDefinition <Composer> filter = Builders <Composer> .Filter.Eq(m => m.Id, mongoId);
var update = Builders <Composer> .Update
.Set("FirstName", composer.FirstName)
.Set("LastName", composer.LastName);
_Context.Composers.FindOneAndUpdate(filter, update);
}
public void doSignup()
{
Composer su = new Composer();
ComposeDAL ldal = new ComposeDAL();
su.subject = txtSubject.Text;
su.message = txtMessage.Text;
su.sender = Session["User"].ToString();
su.reciever = ddReciever.SelectedValue;
ldal.addMessage(su);
}
public Node Compose(Node node, Composer c1, Composer c2)
{
if (node == null)
{
return(null);
}
this.composers.Clear();
this.composers.Add(c1);
this.composers.Add(c2);
return(this.Compose(node, this.composers));
}
public void InitializeWithDefaultConstructorHasCorrectPostprocessors()
{
// Fixture setup
var sut = new Composer <HttpStyleUriParser>();
// Exercise system
IEnumerable <ISpecifiedSpecimenCommand <HttpStyleUriParser> > result = sut.Postprocessors;
// Verify outcome
Assert.NotNull(result);
// Teardown
}
public void Execute(Composer composer, TInstance instance, TData value)
{
composer.Execute(() =>
{
IConsumeContext <TData> context = ContextStorage.MessageContext <TData>();
TMessage message = _messageFactory(instance, context);
instance.Bus.PublishRequest(message, configurator => _configurator(instance, context, configurator));
});
}
public ActionResult Create([Bind(Include = "ID,FullName,Information,LinkImage")] Composer composer)
{
if (ModelState.IsValid)
{
db.Composers.Add(composer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(composer));
}
public void Import_SubPath()
{
// Arrange
// Act
var imports = Composer.Import <IImportTestInterface>(Assembly.GetExecutingAssembly(), "SubPathTest");
// Assert
Assert.NotNull(imports);
imports.Count().Should().Be(0);
}
void StateMachine <TInstance> .RaiseEvent(Composer composer, TInstance instance, Event @event)
{
composer.Execute(() =>
{
State <TInstance> state = _instanceStateAccessor.Get(instance);
State <TInstance> instanceState = _stateCache[state.Name];
return(composer.ComposeEvent(instance, instanceState, @event));
});
}
public void NoNestEnumeratorGeneric()
{
Composer composer = new Composer();
Object[] objects = { new Top(), new Middle(), new Bottom() };
Top top = composer.Compose <Top>(((IEnumerable <Object>)objects).GetEnumerator());
Assert.AreEqual(objects[0], top);
Assert.AreEqual(objects[1], top.Middle);
Assert.AreEqual(objects[2], top.Middle.Bottom);
}
public void Execute(Composer composer, TInstance instance, TData value)
{
composer.Execute(() =>
{
IConsumeContext <TData> context = ContextStorage.MessageContext <TData>();
TMessage message = _messageFactory(instance, context);
context.Respond(message, _contextCallback);
});
}
public HomeScreenController(OrganazerContext context, KeyboardInput parser) : base(context, parser)
{
var matrix = Composer.MakeBoxLayout(49, 16);
Composer.AddHorizontalLine(matrix, 10, 0, 48);
Composer.AddVerticalLine(matrix, 10, 0, 10);
var layout = new Layout(0, 0);
layout.SetLayout(Composer.Compose(matrix));
this.root = layout;
}
public ActionResult Create([Bind(Include = "ComposerID,FirstName,LastName,BirthDate,DeathDate")] Composer composer)
{
if (ModelState.IsValid)
{
db.Composers.Add(composer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(composer));
}
public List <Composer> SelectByName(string name, bool permit, string sex)
{
List <Composer> lstComposer = new List <Composer>();
IQueryable <Composer> temptable = db.Composers;
if (name != "" && name != null)
{
temptable = from a in temptable
where a.ComposerName.StartsWith(name.Trim())
select a;
}
if (sex != "List All" && sex != "")
{
temptable = from a in temptable
where a.Gender == sex
select a;
}
if (permit == true)
{
temptable = from a in temptable
where a.Permit == permit
select a;
}
if (permit == false)
{
temptable = from a in temptable
where a.Permit == permit || a.Permit == null
select a;
}
foreach (var a in temptable)
{
Composer c = new Composer();
c.ComposerID = a.ComposerID;
if (a.Permit == null)
{
c.Permit = false;
}
else
{
c.Permit = a.Permit;
}
c.ComposerName = a.ComposerName;
c.Address = a.Address;
c.Gender = a.Gender;
c.NRC = a.NRC;
c.Phone = a.Phone;
c.CompanyName = a.CompanyName;
lstComposer.Add(c);
}
return(lstComposer.OrderBy(s => s.ComposerName).ToList());
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
Composer composer = (Composer)target;
if (GUILayout.Button("Start Song"))
{
composer.startSong();
}
}
/// <summary>
/// Creates a new Composer, which can be used to compose a task chain, which can be added to an
/// existing composer as a single task. Note that this executes on the task chain, and not immediately.
/// </summary>
/// <typeparam name="T">The payload type</typeparam>
/// <param name="composer">The existing composer</param>
/// <param name="callback"></param>
/// <returns></returns>
public static Composer <T> ComposeTask <T>(this Composer <T> composer, Action <Composer> callback)
{
composer.ExecuteAsync(async(payload, cancellationToken) =>
{
await ComposerFactory.Compose(callback, composer.CancellationToken);
return(composer.Payload);
});
return(composer);
}
public void InitializeWithDefaultConstructorHasCorrectFactory()
{
// Fixture setup
var sut = new Composer <TypeCode>();
// Exercise system
ISpecimenBuilder result = sut.Factory;
// Verify outcome
Assert.IsAssignableFrom <MethodInvoker>(result);
// Teardown
}
/// <summary>
/// Generates nodes for the corners of the Rubik's cube
/// </summary>
/// <returns></returns>
public static List <Node> GenerateCornerNodes()
{
var decomposer = new Decomposer();
var perms = decomposer.Decompose(8);
var finalPerms = perms
.SelectMany(x => decomposer.ApplyTwists(x, 3))
.ToList();
var nodes = Composer.GetNodes(finalPerms);
return(nodes);
}
public void InitializeWithDefaultConstructorHasCorrectEnableAutoProperties()
{
// Fixture setup
var sut = new Composer <PlatformID>();
// Exercise system
bool result = sut.EnableAutoProperties;
// Verify outcome
Assert.False(result);
// Teardown
}
public void SingleNest()
{
Composer composer = new Composer();
Object[] objects = { new MiddleLeft(), new BottomCenter(), new BottomLeft() };
MiddleLeft middleLeft = composer.Compose <MiddleLeft>(objects);
Assert.AreEqual(objects[0], middleLeft);
Assert.AreEqual(objects[1], middleLeft.BottomCenter);
Assert.AreEqual(objects[2], middleLeft.BottomLeft);
}
public Input(int row, int column, string text, int inputFieldLength)
{
int boxWidth = text.Length + inputFieldLength + Padding * 2;
Add(Composer.GetBox(boxWidth, Height, row, column));
int labelColumn = column + Padding;
int labelRow = row + Padding;
Add(new Label(labelRow, labelColumn, text));
}
/// <summary>
/// Creates a <see cref="Composer" /> used to compose parts.
/// </summary>
/// <returns></returns>
protected virtual Composer CreateComposer()
{
var composer = new Composer();
GetDirectoryCatalogs()
.ForEach(composer.AddCatalog);
composer.AddExportProvider(
new DynamicInstantiationExportProvider(),
(provider, container) => ((DynamicInstantiationExportProvider)provider).SourceProvider = container);
return composer;
}
public Notification(Composer.Repository.DataService.Collaboration c, Composer.Modules.Composition.ViewModels.CollaborationNotificationViewModel.Statistics stats)
{
CollaboratorName = c.Name;
CollaboratorId = c.Collaborator_Id;
CollaboratorIndex = c.Index;
LastChangeDate = ((DateTime)c.LastChangeDate).ToShortDateString();
PictureUrl = c.PictureUrl;
Pending = stats.pendingAdds + stats.pendingDeletes;
Accepted = stats.acceptedAddsDeletes;
Rejected = stats.rejectedAdds + stats.rejectedDeletes;
YourChangesAccepted = Pending.ToString();
SuggestionsToYou = Accepted.ToString();
YourChangesRejected = Rejected.ToString();
}
public TestContext(Composer composer, TestFilesRepository testFilesRepository, string testFolder)
{
if (composer == null) throw new ArgumentNullException(nameof(composer));
if (string.IsNullOrWhiteSpace(testFolder)) throw new ArgumentNullException(nameof(testFolder));
_viewModel = composer.Compose();
_composer = composer;
_rootFolder = testFolder;
_sourceDirectory = Path.Combine(_rootFolder, "Source");
_targetDirectory = Path.Combine(_rootFolder, "Target");
_testFilesRepository = testFilesRepository;
if (!Directory.Exists(SourceDirectory)) { Directory.CreateDirectory(SourceDirectory); }
if (!Directory.Exists(TargetDirectory)) { Directory.CreateDirectory(TargetDirectory); }
_logger = _composer.Resolve<Func<string, ILogger>>()("TestContext");
_logger.Info("Root folder is " + _rootFolder);
_logger.Info("Test context hashcode is " + GetHashCode());
}
public override Node Compose( Node node, Composer context, bool hasContextReference, Class scope ) {
switch( node.NodeType ) {
case NodeType.QueryAggregate:
case NodeType.QueryAlias:
case NodeType.QueryAll:
case NodeType.QueryAny:
case NodeType.QueryAxis:
case NodeType.QueryContext:
case NodeType.QueryDelete:
case NodeType.QueryDistinct:
case NodeType.QueryDifference:
case NodeType.QueryExists:
case NodeType.QueryFilter:
case NodeType.QueryGroupBy:
case NodeType.QueryInsert:
case NodeType.QueryIntersection:
case NodeType.QueryIterator:
case NodeType.QueryJoin:
case NodeType.QueryLimit:
case NodeType.QueryOrderBy:
case NodeType.QueryOrderItem:
case NodeType.QueryPosition:
case NodeType.QueryProject:
case NodeType.QueryQuantifiedExpression:
case NodeType.QuerySelect:
case NodeType.QuerySingleton:
case NodeType.QueryTypeFilter:
case NodeType.QueryUnion:
case NodeType.QueryUpdate:
return MakeComposition( node, scope );
default:
if( node is Expression && context == this ) {
return MakeComposition( node, scope );
}
break;
}
return node;
}
/// <summary>
/// The start method of the application.
/// </summary>
protected virtual void Application_Start()
{
// Perform any tasks required before composition.
PreCompose();
// Create the composer used for composition.
Composer = CreateComposer();
// Compose the application.
Compose();
// Set the controller factory.
ControllerBuilder.Current.SetControllerFactory(_controllerFactory);
AreaRegistration.RegisterAllAreas();
// Set the view engine that supports imported areas.
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new AreaViewEngine().DisableVbhtml());
// Initialises the application.
Initialise();
}
/// <summary>
/// The start method of the application.
/// </summary>
protected void Application_Start()
{
// Perform any tasks required before composition.
PreCompose();
// Create the composer used for composition.
Composer = CreateComposer();
// Compose the application.
Compose();
// Set the controller factory.
ControllerBuilder.Current.SetControllerFactory(ControllerFactory);
// Set the view engine that supports imported areas.
// ViewEngines.Engines.Add(new AreaViewEngine());
// Initialises the application.
Initialise();
// Register MVC routes.
RegisterRoutes();
}
public CachingAdapterFactory(Composer composer) : base(composer)
{
}
public override Node VisitQueryLimit(QueryLimit limit) {
limit.Source = this.VisitExpression(limit.Source);
Composer save = this.contextComposer;
Composer c = this.contextComposer = this.GetComposer(limit.Source);
limit.Expression = this.VisitExpression(limit.Expression);
this.contextComposer = save;
return this.Compose(limit, c);
}
void AddCommentTapped()
{
var composer = new Composer();
composer.NewComment(this, () =>
{
var comment = new CommentModel { Content = composer.Text };
composer.DoWork(() =>
{
Application.Client.Users[User].Repositories[Slug].Issues[Id].Comments.Create(comment);
InvokeOnMainThread(() =>
{
composer.CloseComposer();
_scrollToLastComment = true;
Model = null;
UpdateAndRender();
});
}, ex =>
{
Utilities.ShowAlert("Unable to post comment!", ex.Message);
composer.EnableSendButton = true;
});
});
}
public override Node VisitQueryOrderBy(QueryOrderBy orderby) {
orderby.Source = this.VisitExpression(orderby.Source);
Composer save = this.contextComposer;
Composer c = this.contextComposer = this.GetComposer(orderby.Source);
bool savehcr = this.hasContextReference;
this.hasContextReference = false;
this.VisitExpressionList(orderby.OrderList);
this.hasContextReference = savehcr;
this.contextComposer = save;
return this.Compose(orderby, c);
}
public List<Composer> GetData()
{
Composer beethoven = new Composer("Beethoven");
Composition beethovenConcertos = new Composition(CompositionType.Concertos);
Composition beethovenQuartets = new Composition(CompositionType.Quartets);
Composition beethovenSonatas = new Composition(CompositionType.Sonatas);
Composition beethovenSymphonies = new Composition(CompositionType.Symphonies);
beethovenConcertos.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "No. 1 - C" },
new Piece{ Title = "No. 2 - B-Flat Major" },
new Piece{ Title = "No. 3 - C Minor" },
new Piece{ Title = "No. 4 - G Major" },
new Piece{ Title = "No. 5 - E-Flat Major" }
});
beethovenQuartets.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Six String Quartets" },
new Piece{ Title = "Three String Quartets" },
new Piece{ Title = "Grosse Fugue for String Quartets" }
});
beethovenSonatas.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Sonata in A Minor" },
new Piece{ Title = "sonata in F Major" }
});
beethovenSymphonies.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "No. 1 - C Major" },
new Piece{ Title = "No. 2 - D Major" },
new Piece{ Title = "No. 3 - E-Flat Major" },
new Piece{ Title = "No. 4 - B-Flat Major" },
new Piece{ Title = "No. 5 - C Minor" },
new Piece{ Title = "No. 6 - F Major" },
new Piece{ Title = "No. 7 - A Major" },
new Piece{ Title = "No. 8 - F Major" },
new Piece{ Title = "No. 9 - D Minor" }
});
beethoven.Compositions.AddRange(new List<Composition>{
beethovenConcertos,
beethovenQuartets,
beethovenSonatas,
beethovenSymphonies
});
Composer brahms = new Composer("Brahms");
Composition brahmsConcertos = new Composition(CompositionType.Concertos);
Composition brahmsQuartets = new Composition(CompositionType.Quartets);
Composition brahmsSonatas = new Composition(CompositionType.Sonatas);
Composition brahmsSymphonies = new Composition(CompositionType.Symphonies);
brahmsConcertos.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Violin Concerto" },
new Piece{ Title = "Double Concerto - A Minor" },
new Piece{ Title = "Piano Concerto No. 1 - D Minor" },
new Piece{ Title = "Piano Concerto No. 2 - B-Flat Major" }
});
brahmsQuartets.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Piano Quartet No. 1 - G Minor" },
new Piece{ Title = "Piano Quartet No. 2 - A Major" },
new Piece{ Title = "Piano Quartet No. 3 - C Minor" },
new Piece{ Title = "Piano Quartet No. 3 - B-Flat Minor" }
});
brahmsSonatas.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Two Sonatas for Clarinet - F Minor" },
new Piece{ Title = "Two Sonatas for Clarinet - E-Flat Major" }
});
brahmsSymphonies.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "No. 1 - C Minor" },
new Piece{ Title = "No. 2 - D Minor" },
new Piece{ Title = "No. 3 - F Major" },
new Piece{ Title = "No. 4 - E Minor" }
});
brahms.Compositions.AddRange(new List<Composition>{
brahmsConcertos,
brahmsQuartets,
brahmsSonatas,
brahmsSymphonies
});
Composer mozart = new Composer("Mozart");
Composition mozartConcertos = new Composition(CompositionType.Concertos);
mozartConcertos.Pieces.AddRange(new List<Piece> {
new Piece{ Title = "Piano Concerto No. 12" },
new Piece{ Title = "Piano Concerto No. 17" },
new Piece{ Title = "Clarinet Concerto" },
new Piece{ Title = "Violin Concerto No. 5" },
new Piece{ Title = "Violin Concerto No. 4" }
});
mozart.Compositions.Add(mozartConcertos);
return new List<Composer> { beethoven, brahms, mozart };
}
/// <summary>
/// Creates a new instance of the <see cref="LeanEngineAlgorithmHandlers"/> class from the specified composer using type names from configuration
/// </summary>
/// <param name="composer">The composer instance to obtain implementations from</param>
/// <returns>A fully hydrates <see cref="LeanEngineSystemHandlers"/> instance.</returns>
/// <exception cref="CompositionException">Throws a CompositionException during failure to load</exception>
public static LeanEngineAlgorithmHandlers FromConfiguration(Composer composer)
{
var setupHandlerTypeName = Config.Get("setup-handler", "ConsoleSetupHandler");
var transactionHandlerTypeName = Config.Get("transaction-handler", "BacktestingTransactionHandler");
var realTimeHandlerTypeName = Config.Get("real-time-handler", "BacktestingRealTimeHandler");
var dataFeedHandlerTypeName = Config.Get("data-feed-handler", "FileSystemDataFeed");
var resultHandlerTypeName = Config.Get("result-handler", "BacktestingResultHandler");
var historyProviderTypeName = Config.Get("history-provider", "SubscriptionDataReaderHistoryProvider");
var commandQueueHandlerTypeName = Config.Get("command-queue-handler", "EmptyCommandQueueHandler");
var mapFileProviderTypeName = Config.Get("map-file-provider", "LocalDiskMapFileProvider");
var factorFileProviderTypeName = Config.Get("factor-file-provider", "LocalDiskFactorFileProvider");
return new LeanEngineAlgorithmHandlers(
composer.GetExportedValueByTypeName<IResultHandler>(resultHandlerTypeName),
composer.GetExportedValueByTypeName<ISetupHandler>(setupHandlerTypeName),
composer.GetExportedValueByTypeName<IDataFeed>(dataFeedHandlerTypeName),
composer.GetExportedValueByTypeName<ITransactionHandler>(transactionHandlerTypeName),
composer.GetExportedValueByTypeName<IRealTimeHandler>(realTimeHandlerTypeName),
composer.GetExportedValueByTypeName<IHistoryProvider>(historyProviderTypeName),
composer.GetExportedValueByTypeName<ICommandQueueHandler>(commandQueueHandlerTypeName),
composer.GetExportedValueByTypeName<IMapFileProvider>(mapFileProviderTypeName),
composer.GetExportedValueByTypeName<IFactorFileProvider>(factorFileProviderTypeName)
);
}
public override Node VisitQueryIterator(QueryIterator xiterator) {
xiterator.Expression = this.VisitExpression(xiterator.Expression);
Composer c = this.GetComposer(xiterator.Expression);
Composer save = this.contextComposer;
this.contextComposer = c;
this.VisitExpressionList(xiterator.HintList);
this.contextComposer = save;
return (Expression) this.Compose(xiterator, c);
}
static void Attempt(Composer composer, TimeSpan interval, Action<Composer> callback, CancellationToken repeatCancellationToken)
{
composer.ComposeTask(callback);
composer.ExecuteAsync(token =>
{
if (repeatCancellationToken.IsCancellationRequested)
return TaskUtil.Completed();
return ComposerFactory.Compose(x =>
{
x.Delay(interval);
Attempt(x, interval, callback, repeatCancellationToken);
}, token);
}, ExecuteOptions.RunSynchronously);
}
/// <summary>
/// Creates a new instance of the <see cref="LeanEngineSystemHandlers"/> class from the specified composer using type names from configuration
/// </summary>
/// <param name="composer">The composer instance to obtain implementations from</param>
/// <returns>A fully hydrates <see cref="LeanEngineSystemHandlers"/> instance.</returns>
/// <exception cref="CompositionException">Throws a CompositionException during failure to load</exception>
public static LeanEngineSystemHandlers FromConfiguration(Composer composer)
{
return new LeanEngineSystemHandlers(
composer.GetExportedValueByTypeName<IJobQueueHandler>(Config.Get("job-queue-handler")),
composer.GetExportedValueByTypeName<IApi>(Config.Get("api-handler")),
composer.GetExportedValueByTypeName<IMessagingHandler>(Config.Get("messaging-handler"))
);
}
private void HandleEditButton()
{
try
{
var page = CurrentWikiPage(Web.Request);
var wiki = Application.Client.Users[_user].Repositories[_slug].Wikis[page].GetInfo();
var composer = new Composer { Title = "Edit " + Title, Text = wiki.Data, ActionButtonText = "Save" };
composer.NewComment(this, () => {
var text = composer.Text;
composer.DoWork(() => {
Application.Client.Users[_user].Repositories[_slug].Wikis[page].Update(text, Uri.UnescapeDataString("/" + page));
InvokeOnMainThread(() => {
composer.CloseComposer();
Refresh();
});
}, ex =>
{
Utilities.ShowAlert("Unable to update page!", ex.Message);
composer.EnableSendButton = true;
});
});
}
catch (Exception e)
{
Utilities.ShowAlert("Error", e.Message);
}
}
public override Node VisitQueryProject(QueryProject project) {
project.Source = this.VisitExpression(project.Source);
Composer save = this.contextComposer;
Composer c = this.contextComposer = this.GetComposer(project.Source);
bool savehcr = this.hasContextReference;
this.hasContextReference = false;
this.VisitExpressionList(project.ProjectionList);
this.hasContextReference = savehcr;
this.contextComposer = save;
return this.Compose(project, c);
}
public static void AddStaffgroup(Composer.Repository.DataService.Staffgroup staffgroup)
{
var a = (from b in Cache.Staffgroups where b.Id == staffgroup.Id select b);
if (!a.Any())
{
Staffgroups.Add(staffgroup);
}
}
public static void AddMeasure(Composer.Repository.DataService.Measure measure)
{
var a = (from b in Cache.Measures where b.Id == measure.Id select b);
if (!a.Any())
{
Measures.Add(measure);
}
}
public override Node VisitQueryJoin(QueryJoin join) {
join.LeftOperand = this.VisitExpression(join.LeftOperand);
Composer left = this.GetComposer(join.LeftOperand);
join.RightOperand = this.VisitExpression(join.RightOperand);
Composer right = this.GetComposer(join.RightOperand);
Composer save = this.contextComposer;
this.contextComposer = left;
if (this.contextComposer == null)
this.contextComposer = right;
bool savehcr = this.hasContextReference;
this.hasContextReference = false;
join.JoinExpression = this.VisitExpression(join.JoinExpression);
this.hasContextReference = savehcr;
this.contextComposer = save;
return this.Compose(join, left, right);
}
public override Node VisitQueryInsert(QueryInsert insert) {
insert.Location = this.VisitExpression(insert.Location);
this.composers.Clear();
Composer saveContext = this.contextComposer;
bool savehcr = this.hasContextReference;
Composer c = this.contextComposer = this.GetComposer(insert.Location);
this.hasContextReference = false;
this.VisitExpressionList(insert.HintList);
this.VisitExpressionList(insert.InsertList);
this.contextComposer = saveContext;
this.hasContextReference = savehcr;
return this.Compose(insert, c);
}
private void ShowCommentComposer(int? lineFrom, int? lineTo)
{
var composer = new Composer();
composer.NewComment(this, async (text) => {
try
{
await composer.DoWorkAsync("Commenting...", () => ViewModel.PostComment(text, lineFrom, lineTo));
composer.CloseComposer();
}
catch (Exception e)
{
MonoTouch.Utilities.ShowAlert("Unable to Comment".t(), e.Message);
composer.EnableSendButton = true;
}
});
}
public Node Compose(Node node, Composer c1, Composer c2) {
if (node == null) return null;
this.composers.Clear();
this.composers.Add(c1);
this.composers.Add(c2);
return this.Compose(node, this.composers);
}
protected AdapterFactory(Composer composer)
{
_composer = composer;
}
public override Node VisitQueryUpdate( QueryUpdate update ) {
update.Source = this.VisitExpression(update.Source);
Composer saveContext = this.contextComposer;
bool savehcr = this.hasContextReference;
Composer c = this.contextComposer = this.GetComposer(update.Source);
this.hasContextReference = false;
this.VisitExpressionList(update.UpdateList);
this.contextComposer = saveContext;
this.hasContextReference = savehcr;
return this.Compose(update, c);
}
private void PopulateRoot()
{
_title = new InputElement("Title", string.Empty, string.Empty);
_assignedTo = new StyledElement("Responsible", Unassigned, UITableViewCellStyle.Value1)
{
Accessory = UITableViewCellAccessory.DisclosureIndicator,
};
_assignedTo.Tapped += () =>
{
var privileges = new PrivilegesController
{
Username = Username,
RepoSlug = RepoSlug,
Primary = new UserModel { Username = Username },
Title = _assignedTo.Caption,
};
privileges.SelectedItem += obj =>
{
_assignedTo.Value = obj.Username;
NavigationController.PopViewControllerAnimated(true);
};
NavigationController.PushViewController(privileges, true);
};
_issueType = CreateEnumElement("Issue Type", Kinds[0], Kinds);
_priority = CreateEnumElement("Priority", Priorities[0], Priorities);
_content = new MultilinedElement("Description");
_content.Tapped += () =>
{
var composer = new Composer { Title = "Issue Description", Text = _content.Value, ActionButtonText = "Save" };
composer.NewComment(this, () =>
{
var text = composer.Text;
_content.Value = text;
composer.CloseComposer();
});
};
var root = new RootElement(Title) { new Section { _title, _assignedTo, _issueType, _priority }, new Section { _content } };
//See if it's an existing issue or not...
if (ExistingIssue != null)
{
_title.Value = ExistingIssue.Title;
if (ExistingIssue.Responsible != null)
_assignedTo.Value = ExistingIssue.Responsible.Username;
_issueType.Value = ExistingIssue.Metadata.Kind;
_priority.Value = ExistingIssue.Priority;
if (!string.IsNullOrEmpty(ExistingIssue.Content))
_content.Value = ExistingIssue.Content;
_status = CreateEnumElement("Status", ExistingIssue.Status, Statuses);
//Insert the status thing inbetween title and assigned to elements
root[0].Insert(1, _status);
var deleteButton = new StyledElement("Delete Issue", () =>
{
var alert = new UIAlertView
{
Title = "Are you sure?",
Message = "You are about to permanently delete issue #" + ExistingIssue.LocalId + "."
};
alert.CancelButtonIndex = alert.AddButton("Cancel");
var ok = alert.AddButton("Delete");
alert.Clicked += (sender, e) =>
{
if (e.ButtonIndex == ok)
DeleteIssue();
};
alert.Show();
}, Images.BinClosed)
{
Accessory = UITableViewCellAccessory.None,
BackgroundColor = UIColor.FromPatternImage(Images.TableCellRed),
TextColor = UIColor.FromRGB(0.9f, 0.30f, 0.30f)
};
root.Add(new Section { deleteButton });
}
Root = root;
}
private void ChangeDescription()
{
var composer = new Composer { Title = "Description", Text = ViewModel.Description };
composer.NewComment(this, (text) => {
ViewModel.Description = text;
composer.CloseComposer();
});
}
public Constructor(Composer composer)
{
this.composer = composer;
}
public void Add(Composer composer) {
if (composer != null && !this.list.Contains(composer)) {
this.list.Add(composer);
}
}
