public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel root,
String username,
String userEmail,
SqlConnection connection,
TargetingTypeRepository targetingTypeRepository,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var targetingType = targetingTypeRepository.GetTargetingType(root.TargetingType.Id);
var issues = this.modelApplier.ApplyIfValid(
root,
targetingType.Taxonomy,
this.repositoryManager,
username,
userEmail,
connection,
securityRepository,
basketRepository,
portfolioRepository,
ticket,
ref info
);
return(issues);
}
public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel model,
Taxonomy taxonomy,
RepositoryManager repositoryManager,
String username,
String userEmail,
SqlConnection connection,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var issues = this.ValidateModelAndPermissions(model, username, ticket);
var traverser = new IssueTraverser();
var traversedIssues = traverser.TraverseAll(issues);
if (traversedIssues.Any(x => x is ErrorIssue))
{
return(issues);
}
try
{
this.Apply(model, taxonomy, repositoryManager, username, userEmail, connection,
securityRepository, basketRepository, portfolioRepository, ref info);
return(issues);
}
catch (ValidationException exception)
{
return(issues.Union(new IValidationIssue[] { exception.Issue }));
}
}
public IEnumerable <IValidationIssue> ApplyBroadGlobalActiveModelIfValid(ManagingBpt.RootModel root, String username, CalculationTicket ticket)
{
string userEmail = "";
using (var connection = this.usersConnectionFactory.CreateConnection())
{
var manager = this.dataUsersManagerFactory.CreateDataManager(connection, null);
userEmail = manager.GetUserEmail(username);
}
using (var connection = this.connectionFactory.CreateConnection())
{
try
{
using (var ondemandManager = this.CreateOnDemandDataManager(connection))
{
var targetingTypeRepository = this.RepositoryManager.ClaimTargetingTypeRepository(ondemandManager);
var securityRepository = this.RepositoryManager.ClaimSecurityRepository(ondemandManager);
var basketRepository = this.RepositoryManager.ClaimBasketRepository(ondemandManager);
var portfolioRepository = this.RepositoryManager.ClaimPortfolioRepository(ondemandManager);
var calculation = new CalculationInfo();
var issues = this.BptManager.ApplyIfValid(
root,
username,
userEmail,
connection,
targetingTypeRepository,
securityRepository,
basketRepository,
portfolioRepository,
ticket,
ref calculation
);
if (!issues.Any(x => x is ErrorIssue))
{
this.Calculate(calculation.Id, true);
}
return(issues);
}
}
catch (EmailNotificationException e)
{
throw new ApplicationException("Notification email cannot be sent. Data haven't been saved yet. You can try again. If the problem persist contact IT department.", e);
}
catch (CalculationException e)
{
throw new ApplicationException("You change has been saved but portfolio recalculation went wrong. Contact IT department to restart recalculations.", e);
}
catch (OutputTargetingFileException e)
{
throw new ApplicationException("You change has been saved but targeting output file cannot be saved. Contact IT department to restart recalculations.", e);
}
}
}
protected void Apply(
RootModel model,
Taxonomy taxonomy,
RepositoryManager repositoryManager,
String username,
String userEmail,
SqlConnection connection,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
ref CalculationInfo calculationInfo
)
{
using (var transaction = connection.BeginTransaction())
{
var manager = this.dataManagerFactory.CreateDataManager(connection, transaction);
var btChangesetOpt = this.btModelTransformer.TryTransformToChangeset(model, taxonomy);
if (btChangesetOpt != null)
{
// saving unsaved baskets and modified taxonomy
this.btChangesetApplier.Apply(btChangesetOpt, connection, transaction, repositoryManager);
}
var pstoChangesetOpt = this.pstoModelTransformer.TryTransformToChangeset(model, username);
var ttbbvChangesetOpt = this.ttbbvModelTransformer.TryTransformToChangeset(model, username);
var ttbptChangesetOpt = this.ttbptModelTransformer.TryTransformToChangeset(model, username);
if (pstoChangesetOpt == null && ttbbvChangesetOpt == null && ttbptChangesetOpt == null)
{
return; // no changes to apply, why bother?
}
calculationInfo = this.calculationRequester.RequestCalculation(manager);
if (pstoChangesetOpt != null)
{
this.pstoChangesetApplier.Apply(calculationInfo.Id, pstoChangesetOpt, manager);
}
if (ttbbvChangesetOpt != null)
{
this.ttbbvChangesetApplier.Apply(calculationInfo.Id, ttbbvChangesetOpt, manager);
}
if (ttbptChangesetOpt != null)
{
this.ttbptChangesetApplier.Apply(calculationInfo.Id, ttbptChangesetOpt, manager);
}
SendNotification(model.TargetingType.Name, model.Portfolio.Name, pstoChangesetOpt, ttbbvChangesetOpt, ttbptChangesetOpt, manager, securityRepository, basketRepository, portfolioRepository, userEmail);
//#warning HACK!!! prevent test changes to DB
//transaction.Rollback();
transaction.Commit();
}
}
public void Log(ProgressChannel source, ProgressEvent.EventKind kind, ProgressEntry entry)
{
_ectx.AssertValue(source);
_ectx.AssertValueOrNull(entry);
if (kind == ProgressEvent.EventKind.Start)
{
_ectx.Assert(entry == null);
lock (_lock)
{
// Figure out an appropriate name.
int i = 1;
var name = source.Name;
string nameCandidate = name;
while (!_namesUsed.Add(nameCandidate))
{
i++;
nameCandidate = string.Format("{0} #{1}", name, i);
}
var newInfo = new CalculationInfo(++_index, nameCandidate, source);
_infos.Add(newInfo);
_pendingEvents.Enqueue(new ProgressEvent(newInfo.Index, newInfo.Name, newInfo.StartTime, ProgressEvent.EventKind.Start));
return;
}
}
// Not a start event, so we won't modify the _infos.
CalculationInfo info;
lock (_lock)
{
info = _infos.FirstOrDefault(x => x.Channel == source);
if (info == null)
{
throw _ectx.Except("Event sent after the calculation lifetime expired.");
}
}
switch (kind)
{
case ProgressEvent.EventKind.Stop:
_ectx.Assert(entry == null);
info.IsFinished = true;
_pendingEvents.Enqueue(new ProgressEvent(info.Index, info.Name, info.StartTime, ProgressEvent.EventKind.Stop));
break;
default:
_ectx.Assert(entry != null);
_ectx.Assert(kind == ProgressEvent.EventKind.Progress);
_ectx.Assert(!info.IsFinished);
_pendingEvents.Enqueue(new ProgressEvent(info.Index, info.Name, info.StartTime, entry));
break;
}
}
public IEnumerable <IValidationIssue> ApplyBpstModelIfValid(
ManagingBpst.RootModel model,
String username,
CalculationTicket ticket)
{
#warning NEXT: make sure everybody validates before opening a connection
var issues = this.BpstManager.Validate(model, ticket);
if (issues.Any())
{
return(issues);
}
string userEmail = "";
using (var connection = this.usersConnectionFactory.CreateConnection())
{
var manager = this.dataUsersManagerFactory.CreateDataManager(connection, null);
userEmail = manager.GetUserEmail(username);
}
using (var connection = this.connectionFactory.CreateConnection())
{
try
{
CalculationInfo calculationInfo = new CalculationInfo();
var manager = this.dataManagerFactory.CreateDataManager(connection, null);
var retVal = this.BpstManager.ApplyIfValid(model, username, userEmail, connection, ticket, this.RepositoryManager.ClaimSecurityRepository(manager), this.RepositoryManager.ClaimBasketRepository(manager), ref calculationInfo);
if (!retVal.Any())
{
this.Calculate(calculationInfo.Id, true);
}
return(retVal);
}
catch (EmailNotificationException e)
{
throw new ApplicationException("Notification email cannot be sent. Data haven't been saved yet. You can try again. If the problem persist contact IT department.", e);
}
catch (CalculationException e)
{
throw new ApplicationException("You change has been saved but portfolio recalculation went wrong. Contact IT department to restart recalculations.", e);
}
catch (OutputTargetingFileException e)
{
throw new ApplicationException("You change has been saved but targeting output file cannot be saved. Contact IT department to restart recalculations.", e);
}
}
}
public void Apply(RootModel model, String username, String userEmail, SqlConnection connection, SecurityRepository securityRepository, BasketRepository basketRepository, ref CalculationInfo calculationInfo)
{
var ttgbsbvChangesetOpt = this.ttgbsbvModelTransformer.TryTransformToChangeset(username, model);
var bpstChangesetOpt = this.bpstModelTransformter.TryTransformToChangeset(username, model);
if (ttgbsbvChangesetOpt == null && bpstChangesetOpt == null)
{
// there's nothing to apply, why bother?
return;
}
using (var transaction = connection.BeginTransaction())
{
var manager = this.dataManagerFactory.CreateDataManager(connection, transaction);
calculationInfo = this.calculationRequester.RequestCalculation(manager);
if (ttgbsbvChangesetOpt != null)
{
this.ttgbsbvChangesetApplier.Apply(calculationInfo.Id, ttgbsbvChangesetOpt, manager);
}
if (bpstChangesetOpt != null)
{
this.bpstChangesetApplier.Apply(calculationInfo.Id, bpstChangesetOpt, manager);
}
SendNotification(ttgbsbvChangesetOpt, bpstChangesetOpt, manager, securityRepository, basketRepository, userEmail);
transaction.Commit();
}
if (bpstChangesetOpt != null)
{
this.repositoryManager.DropBasketSecurityPortfolioTargetRepository();
}
if (ttgbsbvChangesetOpt != null)
{
this.repositoryManager.DropTargetingTypeGroupBasketSecurityBaseValueRepository();
}
}
public void CalculationInfoTest()
{
var calculationInfo = new CalculationInfo();
calculationInfo.ShowDialog();
}
public IEnumerable <IValidationIssue> ApplyIfValid(RootModel model, String username, String userEmail, SqlConnection connection, CalculationTicket ticket, SecurityRepository securityRepository, BasketRepository basketRepository, ref CalculationInfo calculationInfo)
{
var issues = this.Validate(model, ticket);
if (issues.Any())
{
return(issues);
}
try
{
this.modelApplier.Apply(model, username, userEmail, connection, securityRepository, basketRepository, ref calculationInfo);
return(No.ValidationIssues);
}
catch (ValidationException exception)
{
return(new IValidationIssue[] { exception.Issue });
}
}
public void RunCalculationInFds()
{
// Todo : Bad practice to use such kind of exception handling.
try
{
#region Check if config exists
var pluginConfig = new DefaultFactory(Log).CreateFdsConfig();
if (pluginConfig == null)
{
var fdsConfig = new PluginOptions(Log);
fdsConfig.ShowDialog();
pluginConfig = fdsConfig.PluginConfig;
fdsConfig.Dispose();
fdsConfig = null;
}
#endregion
#region Collect information
// Ask user to configure calculation
var calculationInfo = new CalculationInfo();
var dialogResult = calculationInfo.ShowDialog();
var calcTime = calculationInfo.CalculationTime;
var workingDir = calculationInfo.OutputPath;
calculationInfo.Dispose();
calculationInfo = null;
if (dialogResult == DialogResult.Cancel)
{
return;
}
EditMaterialsMappings();
// get solids
var selectedSolids = AcadInfoProvider.AskUserToSelectSolids();
if (selectedSolids.Count < 1)
{
return;
}
#endregion
#region Start Calculations
var fdsStartInfo = new FdsStartInfo
{
// Arguments = string.Concat("\"", pathToFile, "\""),
CalculationTime = calcTime,
DocumentName = AcadInfoProvider.GetDocumentName(),
PathToFds = pluginConfig.PathToFds,
SelectedSolids = selectedSolids,
UsedSurfaces = CommonHelper.GetAllUsedSurfaces(Log),
WorkingDirectory = workingDir
};
var progressWindow = new ConversionProgress(fdsStartInfo.SelectedSolids.Count);
var calculationManager = new ThreadedCalculationManager(fdsStartInfo, Log, progressWindow);
progressWindow.Shown += (s, e) => calculationManager.WaitEvent.Set();
calculationManager.StartCalculation();
progressWindow.ShowDialog();
progressWindow.Dispose();
progressWindow = null;
#endregion
}
catch (System.Exception exception)
{
Log.LogError(exception);
UserNotifier.ShowError(exception.Message);
}
}
public IEnumerable <IValidationIssue> ApplyIsValid(RootModel composition, String username, String userEmail, SqlConnection connection, CalculationTicket ticket, SecurityRepository securityRepository, ref CalculationInfo info)
{
var issues = this.modelValidator.ValidateRoot(composition, ticket);
if (issues.Any())
{
return(issues);
}
try
{
var changesetOpt = this.transformer.TryTransformToChangeset(username, composition);
if (changesetOpt != null)
{
using (var transaction = connection.BeginTransaction())
{
var manager = this.dataManagerFactory.CreateDataManager(connection, transaction);
info = this.calculationRequester.RequestCalculation(manager);
this.applier.Apply(info.Id, changesetOpt, manager);
try
{
var message = this.applier.PrepareToSend(changesetOpt, manager, securityRepository);
MailSender.SendTargetingAlert(message, userEmail);
}
catch (Exception e)
{
throw new EmailNotificationException("See inner exception for details.", e);
}
// it's important to drop the repository (or at least part of it if you can manage to carefully resolve everything) as we changed the composition
this.repositoryManager.DropRepository();
transaction.Commit();
}
}
return(No.ValidationIssues);
}
catch (ValidationException exception)
{
return(new IValidationIssue[] { exception.Issue });
}
}
