public async Task <IActionResult> Sequence(Guid applicationId, int sequenceNo, BackViewModel backViewModel)
{
var application = await _applyApiClient.GetApplication(applicationId);
var organisation = await _apiClient.GetOrganisation(application.OrganisationId);
var applySequence = application.ApplyData.Sequences.Single(x => x.SequenceNo == sequenceNo);
var sequence = await _qnaApiClient.GetSequence(application.ApplicationId, applySequence.SequenceId);
var sections = await _qnaApiClient.GetSections(application.ApplicationId, sequence.Id);
var sequenceVm = new SequenceViewModel(application, organisation, sequence, sections,
applySequence.Sections, backViewModel.BackAction, backViewModel.BackController,
backViewModel.BackOrganisationId);
var activeApplicationStatuses = new List <string> {
ApplicationStatus.Submitted, ApplicationStatus.Resubmitted
};
var activeSequenceStatuses = new List <string> {
ApplicationSequenceStatus.Submitted, ApplicationSequenceStatus.Resubmitted
};
if (activeApplicationStatuses.Contains(application.ApplicationStatus) && activeSequenceStatuses.Contains(applySequence?.Status))
{
return(View(nameof(Sequence), sequenceVm));
}
else
{
return(View($"{nameof(Sequence)}_ReadOnly", sequenceVm));
}
}
public void CanAddEventToSubsequence(Subsequence subsequence)
{
var evt = new OutputEvent
{
ChannelName = "Channel",
StartTime = TimeSpan.Zero,
EndTime = TimeSpan.FromSeconds(1)
};
var viewModel = new SequenceViewModel(new Sequence());
viewModel.CreateEventRequest.Raised += (o, e) =>
{
var confirmation = (IConfirmation)e.Context;
confirmation.Confirmed = true;
confirmation.Content = evt;
e.Callback();
};
viewModel.AddEventCommand.Execute(subsequence.ToString());
var seq = (subsequence == Subsequence.Primary ? viewModel.Sequence.PrimarySequence : viewModel.Sequence.AbortSequence);
Assert.Single(seq);
Assert.Same(evt, seq.First());
}
public void OpenOpenedSequenceActivatesExistingSequence()
{
var regionManager = A.Fake <IRegionManager>();
var regionName = "Region";
var path = "Path";
var sequence = new SequenceViewModel(new Sequence());
var region = new Region();
region.Add(new SequenceFile(path, sequence), path);
var regionCollection = A.Fake <IRegionCollection>();
A.CallTo(() => regionCollection[regionName]).Returns(region);
A.CallTo(() => regionManager.Regions).Returns(regionCollection);
var service = new SequenceEditorService(regionManager);
service.OpenSequenceInRegion(regionName, path, sequence);
Assert.Single(region.Views);
Assert.Single(region.ActiveViews);
Assert.IsType <SequenceFile>(region.ActiveViews.First());
var view = (SequenceFile)region.ActiveViews.First();
Assert.Equal(path, view.Path);
Assert.Equal(sequence, view.Sequence);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sequenceViewModel"></param>
public SelectFormatterView(SequenceViewModel sequenceViewModel)
{
Loaded += SelectFormatterView_Loaded;
DataContext = sequenceViewModel;
CommandBindings.Add(new CommandBinding(ApplicationCommands.Close, OnOk, (s, e) => e.CanExecute = cbFormatters.SelectedItem != null));
InitializeComponent();
}
public ActionResult Sequences()
{
List <OrderDetail> sequences = new List <OrderDetail>();
List <Customer> customers = new List <Customer>();
using (var context = new MainContext())
{
foreach (var orderDetail in context.OrderDetails)
{
//get customer Name for last order
var ClientOrder = context.Orders.Where(c => c.OrderId == orderDetail.OrderId);
customers.Add(ClientOrder.Select(c => c.Customer).First());
var ClientSequence = context.OrderDetails.Where(c => c.OrderId == orderDetail.OrderId).First();
sequences.Add(ClientSequence);
}
}
SequenceViewModel seqVM = new SequenceViewModel();
foreach (var customer in customers)
{
var cId = customer.CustomerId;
var cName = customer.Name;
var cVM = new CustomerVM();
cVM.customerId = cId;
cVM.customerName = cName;
seqVM.Customer.Add(cVM);
}
foreach (var orderDetail in sequences)
{
var oId = orderDetail.OrderId;
var bPrefix = orderDetail.barcodePrefix;
var bStartSequence = orderDetail.startSequence;
var bSuffix = orderDetail.barcodeSuffix;
var bEndSequence = orderDetail.endSequence;
var odVM = new OrderDetailVM();
odVM.OrderId = oId;
odVM.barcodePrefix = bPrefix;
odVM.startSequence = bStartSequence;
odVM.barcodeSuffix = bSuffix;
odVM.endSequence = bEndSequence;
seqVM.OrderDetails.Add(odVM);
}
return(View(seqVM));
}
public ActionResult Index(SequenceViewModel model)
{
model.allNumbers = String.Join(", ", GetAllNumbers(model.input));
model.evenNumbers = String.Join(", ", GetEvenNumbers(model.input));
model.oddNumbers = String.Join(", ", GetOddNumbers(model.input));
model.fizzBuzzNumbers = String.Join(", ", GetFizzBuzzNumbers(model.input));
model.fibonacciNumbers = String.Join(", ", GetFibonacciNumbers(model.input));
return(View(model));
}
// GET: Sequence
public ActionResult Index()
{
var sequenceTypes = _sequenceService.GetAvailableSequenceTypesInfo();
var model =
new SequenceViewModel
{
AvailableSequenceTypes = sequenceTypes,
};
return(View(model));
}
public static void Create()
{
var viewModel = new SequenceViewModel(Rock.Make <IJSRuntime>().Instance());
Assert.Multiple(() =>
{
Assert.That(viewModel.ChartReference, Is.EqualTo(default(ElementReference)), nameof(viewModel.Changed));
Assert.That(viewModel.CurrentSequence, Is.EqualTo(string.Empty), nameof(viewModel.CurrentSequence));
Assert.That(viewModel.Labels, Is.EqualTo(Array.Empty <string>()), nameof(viewModel.Labels));
Assert.That(viewModel.Sequence, Is.EqualTo(Array.Empty <int>()), nameof(viewModel.Sequence));
Assert.That(viewModel.Value, Is.Null, nameof(viewModel.Value));
});
}
public void OpenSequenceInRegion(string editorRegionName, string path, SequenceViewModel sequence)
{
var editorRegion = regionManager.Regions[editorRegionName];
if (editorRegion.GetView(path) != null)
{
editorRegion.Activate(editorRegion.GetView(path));
return;
}
var view = new SequenceFile(path, sequence);
editorRegion.Add(view, path);
editorRegion.Activate(view);
}
public ActionResult GenerateSequence(string selectedSequenceType, int requestedNumberOfItems)
{
var sequenceType = (SequenceType)Enum.Parse(typeof(SequenceType), selectedSequenceType, ignoreCase: true);
var strategy = _sequenceStrategyFactory.CreateSequenceStrategy(sequenceType);
var sequenceItems = _sequenceService.GenerateSequence(strategy, requestedNumberOfItems);
var sequenceTypes = _sequenceService.GetAvailableSequenceTypesInfo();
var model =
new SequenceViewModel
{
AvailableSequenceTypes = sequenceTypes,
SelectedSequenceType = selectedSequenceType,
RequestedNumberOfItems = requestedNumberOfItems,
SequenceItems = sequenceItems
};
return(View(viewName: "Index", model: model));
}
public async Task <IActionResult> ActiveSequence(Guid applicationId, BackViewModel backViewModel)
{
var application = await _applyApiClient.GetApplication(applicationId);
var organisation = await _apiClient.GetOrganisation(application.OrganisationId);
var activeApplySequence = application.ApplyData.Sequences.Where(seq => seq.IsActive && !seq.NotRequired).OrderBy(seq => seq.SequenceNo).FirstOrDefault();
var sequence = await _qnaApiClient.GetSequence(application.ApplicationId, activeApplySequence.SequenceId);
var sections = await _qnaApiClient.GetSections(application.ApplicationId, sequence.Id);
var sequenceVm = new SequenceViewModel(application, organisation, sequence, sections,
activeApplySequence.Sections,
backViewModel.BackAction,
backViewModel.BackController,
backViewModel.BackOrganisationId);
return(View(nameof(Sequence), sequenceVm));
}
public async Task <IActionResult> Sequence(Guid Id, int sequenceNo)
{
var sequence = await _qnaApiClient.GetSequenceBySequenceNo(Id, sequenceNo);
var sections = await _qnaApiClient.GetSections(Id, sequence.Id);
var applySection = new List <ApplySection>();
foreach (var section in sections)
{
applySection.Add(new ApplySection
{
SectionId = section.Id,
SectionNo = section.SectionNo,
Status = section.Status
});
}
var sequenceVm = new SequenceViewModel(sequence, Id, OrganisationName, sections, applySection, null);
return(View(sequenceVm));
}
public void UpdateViewNameRemovesOldSequenceAndAddsNewOne()
{
var regionManager = A.Fake <IRegionManager>();
var regionName = "Region";
var oldPath = "Path";
var newPath = "Path2";
var sequence = new SequenceViewModel(new Sequence());
var region = new Region();
var sequenceFile = new SequenceFile(oldPath, sequence);
region.Add(sequenceFile, oldPath);
var regionCollection = A.Fake <IRegionCollection>();
A.CallTo(() => regionCollection[regionName]).Returns(region);
A.CallTo(() => regionManager.Regions).Returns(regionCollection);
var service = new SequenceEditorService(regionManager);
service.UpdateViewNameForSequence(regionName, newPath, sequenceFile);
Assert.Single(region.Views);
Assert.Equal(sequence, ((SequenceFile)region.GetView(newPath)).Sequence);
Assert.Null(region.GetView(oldPath));
}
public void CannotAddEventToInvalidSubsequence()
{
var viewModel = new SequenceViewModel(new Sequence());
Assert.False(viewModel.AddEventCommand.CanExecute("Invalid"));
}
public AddEventButtonCommand(SequenceViewModel sequenceViewModel)
{
this.viewModel = sequenceViewModel;
}
public SequenceLeftClickEvent(SequenceViewModel viewModel)
{
this.viewModel = viewModel;
}
public async Task <IActionResult> Align(SequenceViewModel Model, IFormFile FirstFile, IFormFile SecondFile)
{
if (!string.IsNullOrWhiteSpace(Model.FirstSequence))
{
Model.FirstSequence = Model.FirstSequence.Trim().Replace(" ", string.Empty).ToUpper();
}
if (!string.IsNullOrWhiteSpace(Model.SecondSequence))
{
Model.SecondSequence = Model.SecondSequence.Trim().Replace(" ", string.Empty).ToUpper();
}
if (string.IsNullOrWhiteSpace(Model.FirstSequence) && FirstFile != null)
{
if (FirstFile.ContentType == "text/plain")
{
string FirstSequence = (await Helper.ConvertFileByteToByteStringAsync(FirstFile)).Trim().Replace(" ", string.Empty).ToUpper();
if (FirstSequence.Length > 10000)
{
return(RedirectToAction("Grid", "Alignment"));
}
else if (FirstSequence.Length == 0)
{
return(View("Error", new ErrorViewModel {
Message = "You Can't send a sequence of 0 Length", Solution = "You should send a sequence greater than 0 length"
}));
}
else
{
Model.FirstSequence = FirstSequence;
}
}
else
{
return(View("Error", new ErrorViewModel {
Message = "You Can't upload a file of any type rather than txt file format", Solution = "You should upload a file of txt file format"
}));
}
}
if (string.IsNullOrWhiteSpace(Model.SecondSequence) && SecondFile != null)
{
if (SecondFile.ContentType == "text/plain")
{
string SecondSequence = (await Helper.ConvertFileByteToByteStringAsync(SecondFile)).Trim().Replace(" ", string.Empty).ToUpper();
if (SecondSequence.Length > 10000)
{
return(RedirectToAction("Grid", "Alignment"));
}
else if (SecondSequence.Length == 0)
{
return(View("Error", new ErrorViewModel {
Message = "You Can't send a sequence of 0 Length", Solution = "You should send a sequence greater than 0 length"
}));
}
else
{
Model.SecondSequence = SecondSequence;
}
}
else
{
return(View("Error", new ErrorViewModel {
Message = "You Can't upload a file of any type rather than txt file format", Solution = "You should upload a file of txt file format"
}));
}
}
if ((Model.FirstSequence == null && FirstFile == null) || (Model.SecondSequence == null && SecondFile == null))
{
return(View("Error", new ErrorViewModel {
Message = "You Can't enter an empty sequence", Solution = "You have to enter the sequence or either upload a file contains the sequence"
}));
}
if (!Regex.IsMatch(Model.FirstSequence, @"^[a-zA-Z]+$") || !Regex.IsMatch(Model.SecondSequence, @"^[a-zA-Z]+$"))
{
return(View("Error", new ErrorViewModel {
Message = "Your sequence must contains only characters", Solution = "Send sequence contains only characters"
}));
}
AlignmentJob JobFound = Repo.AreExist(Model.FirstSequence, Model.SecondSequence, Model.ScoringMatrix, Model.Gap);
if (JobFound == null)
{
JobFound = new AlignmentJob()
{
AlignmentID = Guid.NewGuid().ToString(),
Algorithm = Model.Algorithm,
ScoringMatrix = Model.ScoringMatrix,
FirstSequenceHash = Helper.SHA1HashStringForUTF8String(Model.FirstSequence),
SecondSequenceHash = Helper.SHA1HashStringForUTF8String(Model.SecondSequence),
FirstSequenceName = Model.FirstSequenceName,
SecondSequenceName = Model.SecomdSequenceName,
GapOpenPenalty = Model.GapOpenPenalty,
Gap = Model.Gap,
GapExtensionPenalty = Model.GapExtensionPenalty,
IsAlignmentCompleted = true,
};
SequenceAligner AlgorithmInstance = DynamicInvoke.GetAlgorithm(Model.Algorithm);
ScoringMatrix ScoringMatrixInstance = DynamicInvoke.GetScoreMatrix(Model.ScoringMatrix);
string AlignmentResult = string.Empty;
float AlignmentScore = 0.0f;
AlignedSequences Result = AlgorithmInstance.Align(Model.FirstSequence, Model.SecondSequence, ScoringMatrixInstance, Model.Gap);
AlignmentResult = Result.StandardFormat(210);
AlignmentScore = Result.AlignmentScore(ScoringMatrixInstance);
JobFound.ByteText = Helper.GetText(AlignmentResult,
AlignmentScore,
JobFound.AlignmentID,
Model.Algorithm,
Model.ScoringMatrix,
Model.Gap,
Model.GapOpenPenalty,
Model.GapExtensionPenalty);
JobFound.UserFK = UserManager.GetUserId(User);
await Repo.AddAlignmentJobAsync(JobFound);
if (Model.DownloadDirectly == 1)
{
return(File(JobFound.ByteText, "text/plain", $"{JobFound.AlignmentID}_Alignment_Result.txt"));
}
else
{
return(RedirectToAction("Display", "Profile", new { AlignmentID = JobFound.AlignmentID }));
}
}
else
{
if (Model.DownloadDirectly == 1)
{
return(File(JobFound.ByteText, "text/plain", $"{JobFound.AlignmentID}_Alignment_Result.txt"));
}
else
{
return(RedirectToAction("Display", "Profile", new { AlignmentID = JobFound.AlignmentID }));
}
}
}
public SequenceViewTest()
{
sut = new SequenceViewModel <int>(seq);
}
public ActionResult Index()
{
var model = new SequenceViewModel();
return(View(model));
}
public SequenceFile(string path, SequenceViewModel sequence)
{
Path = path;
Sequence = sequence;
}
public Sequence()
{
InitializeComponent();
_viewModel = (SequenceViewModel)LayoutRoot.DataContext;
DataContext = _viewModel;
}
public DeleteSequenceButtonCommand(SequenceViewModel viewModel)
{
this.viewModel = viewModel;
}
