protected override void CreateNodeActions()
{
NodeActionsList.Clear();
var addAction = new JournalAction("Добавить расходный ордер",
selected => true,
selected => true,
selected =>
{
var selectedNodes = selected.OfType <EmployeeJournalNode>();
var node = selectedNodes.FirstOrDefault();
if (node == null)
{
commonServices.InteractiveService.ShowMessage(ImportanceLevel.Warning, "Не выбран сотрудник");
}
else
{
_gtkTabsOpener.OpenCashExpenseDlg(master: this, node.Id, node.Balance, _permissionService, canChangeEmployee: false,
ExpenseType.Salary);
}
},
hotKeys: "Insert");
RowActivatedAction = addAction;
NodeActionsList.Add(addAction);
}
/// <summary>
/// Gets the journal actions from the database.
/// </summary>
/// <returns>Dictionary containing journal actions as a key and id of the action as a value.</returns>
public Dictionary <JournalAction, Guid> GetJournalActions()
{
XDocument xml = this.ExecuteStoredProcedure(StoredProcedure.journal_p_getJournalActions);
Dictionary <JournalAction, Guid> dictActions = new Dictionary <JournalAction, Guid>();
string[] journalActions = Enum.GetNames(typeof(JournalAction));
foreach (XElement entry in xml.Root.Elements())
{
Guid id = new Guid(entry.Element("id").Value);
JournalAction action = JournalAction.Unspecified;
if (journalActions.Contains(entry.Element("name").Value))
{
action = (JournalAction)Enum.Parse(typeof(JournalAction), entry.Element("name").Value);
}
if (action != JournalAction.Unspecified)
{
dictActions.Add(action, id);
}
}
return(dictActions);
}
private void CreateAutomaticallyAllocationAction()
{
var automaticallyAllocationAction = new JournalAction("Автоматическое распределение положительного баланса",
(selected) => _canEdit && selected.Any(),
(selected) => true,
(selected) =>
{
var ctorTypes = new[]
{
typeof(IUnitOfWork),
typeof(UnallocatedBalancesJournalNode),
typeof(int),
typeof(IList <UnallocatedBalancesJournalNode>)
};
var ctorValues = new object[] {
UoW,
selected.OfType <UnallocatedBalancesJournalNode>().ToArray()[0],
_closingDocumentDeliveryScheduleId,
Items
};
ShowInfoMessage("Будет произведен разнос всех нераспределенных платежей по неоплаченным заказам, начиная с самого раннего");
var page = NavigationManager.OpenViewModelTypedArgs <AutomaticallyAllocationBalanceWindowViewModel>(
this, ctorTypes, ctorValues, OpenPageOptions.IgnoreHash);
page.PageClosed += (sender, args) => Refresh();
}
);
NodeActionsList.Add(automaticallyAllocationAction);
}
void CreateActions()
{
var loadAllAction = new JournalAction("Загрузить всех",
(selected) => true,
(selected) => true,
(selected) => LoadAll()
);
NodeActionsList.Add(loadAllAction);
var editAction = new JournalAction("Открыть сотрудника",
(selected) => selected.Any(),
(selected) => VisibleEditAction,
(selected) => selected.Cast <EmployeeProcessingJournalNode>().ToList().ForEach(EditEntityDialog)
);
NodeActionsList.Add(editAction);
RowActivatedAction = editAction;
var updateStatusAction = new JournalAction("Установить по должности",
(selected) => selected.Any(),
(selected) => true,
(selected) => UpdateNorms(selected.Cast <EmployeeProcessingJournalNode>().ToArray())
);
NodeActionsList.Add(updateStatusAction);
var RecalculateAction = new JournalAction("Пересчитать",
(selected) => selected.Any(),
(selected) => true
);
NodeActionsList.Add(RecalculateAction);
var UpdateNextIssueAction = new JournalAction("Даты следующего получения",
(selected) => selected.Any(),
(selected) => true,
(selected) => UpdateNextIssue(selected.Cast <EmployeeProcessingJournalNode>().ToArray())
);
RecalculateAction.ChildActionsList.Add(UpdateNextIssueAction);
var UpdateLastIssueAction = new JournalAction("Сроки носки у полученного",
(selected) => selected.Any(),
(selected) => true,
(selected) => UpdateLastIssue(selected.Cast <EmployeeProcessingJournalNode>().ToArray())
);
RecalculateAction.ChildActionsList.Add(UpdateLastIssueAction);
var logAction = new JournalAction("Лог выполнения",
(selected) => File.Exists(logFile),
(selected) => true,
(selected) => System.Diagnostics.Process.Start(logFile)
);
NodeActionsList.Add(logAction);
}
private void CreateCustomEditAction()
{
var editAction = new JournalAction("Изменить",
(selected) =>
{
var selectedNodes = selected.OfType <EmployeeJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return(false);
}
EmployeeJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanRead);
},
(selected) => true,
(selected) =>
{
var selectedNodes = selected.OfType <EmployeeJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return;
}
EmployeeJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
var foundDocumentConfig = config.EntityDocumentConfigurations.FirstOrDefault(x => x.IsIdentified(selectedNode));
TabParent.OpenTab(() => foundDocumentConfig.GetOpenEntityDlgFunction().Invoke(selectedNode), this);
if (foundDocumentConfig.JournalParameters.HideJournalForOpenDialog)
{
HideJournal(TabParent);
}
}
);
if (SelectionMode == JournalSelectionMode.None)
{
RowActivatedAction = editAction;
}
NodeActionsList.Add(editAction);
}
void CreateDocumentsActions()
{
var addAction = new JournalAction("Добавить",
(selected) => true,
(selected) => true,
null,
"Insert"
);
NodeActionsList.Add(addAction);
foreach (StokDocumentType docType in Enum.GetValues(typeof(StokDocumentType)))
{
switch (docType)
{
case StokDocumentType.CollectiveExpense when !FeaturesService.Available(WorkwearFeature.CollectiveExpense):
case StokDocumentType.TransferDoc when !FeaturesService.Available(WorkwearFeature.Warehouses):
case StokDocumentType.Completion when !FeaturesService.Available(WorkwearFeature.Completion):
continue;
default:
{
var insertDocAction = new JournalAction(
docType.GetEnumTitle(),
(selected) => true,
(selected) => true,
(selected) => openStockDocumentsModel.CreateDocumentDialog(this, docType)
);
addAction.ChildActionsList.Add(insertDocAction);
break;
}
}
}
var editAction = new JournalAction("Изменить",
(selected) => selected.Any(),
(selected) => true,
(selected) => selected.Cast <StockDocumentsJournalNode>().ToList()
.ForEach(n => openStockDocumentsModel.EditDocumentDialog(this, n.DocTypeEnum, n.Id))
);
NodeActionsList.Add(editAction);
if (SelectionMode == JournalSelectionMode.None)
{
RowActivatedAction = editAction;
}
var deleteAction = new JournalAction("Удалить",
(selected) => selected.Any(),
(selected) => true,
(selected) => DeleteEntities(selected.Cast <StockDocumentsJournalNode>().ToArray()),
"Delete"
);
NodeActionsList.Add(deleteAction);
}
void CreateActions()
{
var updateStatusAction = new JournalAction("Запросить статус доставки",
(selected) => selected.Any(),
(selected) => true,
(selected) => UpdateStatus(selected.Cast <MessagesJournalNode>().ToArray())
);
NodeActionsList.Add(updateStatusAction);
}
protected override void CreateNodeActions()
{
base.CreateNodeActions();
var updateStatusAction = new JournalAction("Открыть документ",
(selected) => selected.Cast <StockMovmentsJournalNode>().Any(x => x.DocumentId.HasValue),
(selected) => true,
(selected) => OpenDocument(selected.Cast <StockMovmentsJournalNode>().ToArray())
);
NodeActionsList.Add(updateStatusAction);
}
/// <summary>
/// Logs action to the journal.
/// </summary>
/// <param name="userId">Id of the user that caused the action.</param>
/// <param name="action">The action.</param>
/// <param name="firstObjectId">First object id parameter.</param>
/// <param name="secondObjectId">Second object id parameter.</param>
/// <param name="thirdObjectId">Third object id parameter.</param>
/// <param name="xmlParams">Xml parameters.</param>
public void LogToJournal(Guid?userId, JournalAction action, Guid?firstObjectId, Guid?secondObjectId, Guid?thirdObjectId, XDocument xmlParams)
{
JournalMapper mapper = DependencyContainerManager.Container.Get <JournalMapper>();
if (!dictActions.ContainsKey(action))
{
throw new InvalidOperationException(String.Format("Missing journal action: {0}", action.ToString()));
}
mapper.LogToJournal(userId, this.dictActions[action], firstObjectId, secondObjectId,
thirdObjectId, xmlParams, Assembly.GetExecutingAssembly().GetName().Version.ToString());
}
protected override void CreateNodeActions()
{
base.CreateNodeActions();
var updateStatusAction = new JournalAction("Показать движения",
(selected) => selected.Any() && Filter.Warehouse != null,
(selected) => true,
(selected) => OpenMovements(selected.Cast <StockBalanceJournalNode>().ToArray())
);
NodeActionsList.Add(updateStatusAction);
}
/// <summary>
/// Get Journal Action
/// </summary>
/// <param name="boNodeName"></param>
/// <param name="isNew"></param>
/// <returns></returns>
public static JournalAction GetJournalAction(string boNodeName, bool isNew)
{
JournalAction action = JournalAction.Unspecified;
switch (boNodeName)
{
case "COMMERCIALDOCUMENT":
case "COMPLAINTDOCUMENT":
case "FINANCIALDOCUMENT":
case "FINANCIALREPORT":
case "INVENTORYDOCUMENT":
case "SERVICEDOCUMENT":
case "WAREHOUSEDOCUMENT":
if (isNew)
{
action = JournalAction.Document_New;
}
else
{
action = JournalAction.Document_Edit;
}
break;
case "CONTRACTOR":
if (isNew)
{
action = JournalAction.Contractor_New;
}
else
{
action = JournalAction.Contractor_Edit;
}
break;
case "ITEM":
if (isNew)
{
action = JournalAction.Item_New;
}
else
{
action = JournalAction.Item_Edit;
}
break;
case "CONFIGVALUE":
case "SLOTGROUP": //<warehouseMap><slotGroup>......</warehouseMap>
action = JournalAction.ConfigValue_Edit;
break;
}
return(action);
}
private void OverrideDeleteAction()
{
NodeActionsList.RemoveAll(x => x.Title == "Удалить");
var deleteAction = new JournalAction("Удалить",
(selected) => selected.Length == 1 && selected.First().GetId() >= SizeService.MaxStandartSizeTypeId,
(selected) => VisibleDeleteAction,
(selected) => DeleteEntities((SizeTypeJournalNode[])selected.ToArray()),
"Delete"
);
NodeActionsList.Add(deleteAction);
}
private void CreateDeleteAction()
{
if (_commonServices.UserService.GetCurrentUser(UoW).IsAdmin)
{
var deleteAction = new JournalAction("Удалить",
(selected) => _paymentPermissionResult.CanDelete && selected.Any(),
(selected) => VisibleDeleteAction,
(selected) => DeleteEntities(selected.OfType <PaymentJournalNode>().ToArray()),
"Delete"
);
NodeActionsList.Add(deleteAction);
}
}
void CreateDeleteAction()
{
var deleteAction = new JournalAction("Удалить",
(selected) => {
var selectedNodes = selected.OfType <CashRequestJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return(false);
}
CashRequestJournalNode selectedNode = selectedNodes.First();
if (selectedNode.State != CashRequest.States.New)
{
return(false);
}
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanDelete);
},
(selected) => true,
(selected) => {
var selectedNodes = selected.OfType <CashRequestJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return;
}
CashRequestJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
if (config.PermissionResult.CanDelete)
{
DeleteHelper.DeleteEntity(selectedNode.EntityType, selectedNode.Id);
}
},
"Delete"
);
NodeActionsList.Add(deleteAction);
}
private void CreateStopOnlineDeliveriesTodayAction()
{
var stopOnlinesAction = new JournalAction("Остановить онлайны",
selectedItems => true,
selected => _сanChangeOnlineDeliveriesToday && !IsStoppedOnlineDeliveriesToday,
selected =>
{
_deliveryRulesParametersProvider.UpdateOnlineDeliveriesTodayParameter("true");
SetIsStoppedOnlineDeliveriesToday();
UpdateJournalActions?.Invoke();
}
);
NodeActionsList.Add(stopOnlinesAction);
}
private void CreateCopyAction()
{
var copyAction = new JournalAction("Копировать",
selectedItems => canCreate &&
selectedItems.OfType <FinancialDistrictsSetsJournalNode>().FirstOrDefault() != null,
selected => true,
selected => {
var selectedNode = selected.OfType <FinancialDistrictsSetsJournalNode>().FirstOrDefault();
if (selectedNode == null)
{
return;
}
var districtsSetToCopy = UoW.GetById <FinancialDistrictsSet>(selectedNode.Id);
var alreadyCopiedDistrict =
UoW.Session.QueryOver <FinancialDistrict>()
.WhereRestrictionOn(x => x.CopyOf.Id)
.IsIn(districtsSetToCopy.FinancialDistricts.Select(x => x.Id).ToArray())
.Take(1)
.SingleOrDefault();
if (alreadyCopiedDistrict != null)
{
commonServices.InteractiveService.ShowMessage(ImportanceLevel.Warning,
$"Выбранная версия районов уже была скопирована\nКопия: {alreadyCopiedDistrict.FinancialDistrictsSet.Id} {alreadyCopiedDistrict.FinancialDistrictsSet.Name}");
return;
}
if (commonServices.InteractiveService.Question($"Скопировать версию районов \"{selectedNode.Name}\""))
{
var copy = districtsSetToCopy.Clone() as FinancialDistrictsSet;
copy.Name += " - копия";
copy.Author = employeeService.GetEmployeeForUser(UoW, commonServices.UserService.CurrentUserId);
copy.Status = DistrictsSetStatus.Draft;
copy.DateCreated = DateTime.Now;
UoW.Save(copy);
UoW.Commit();
commonServices.InteractiveService.ShowMessage(ImportanceLevel.Info, "Копирование завершено");
Refresh();
}
}
);
NodeActionsList.Add(copyAction);
}
private void CreateXLExportAction()
{
var xlExportAction = new JournalAction("Экспорт в Excel",
(selected) => true,
(selected) => true,
(selected) =>
{
var rows = ItemsSourceQueryFunction.Invoke(UoW)
.List <FastDeliveryAvailabilityHistoryJournalNode>();
var report = new FastDeliveryAvailabilityHistoryReport(rows, _fileDialogService);
report.Export();
}
);
NodeActionsList.Add(xlExportAction);
}
private void CreateCustomDeleteAction()
{
var deleteAction = new JournalAction("Удалить",
(selected) =>
{
var selectedNodes = selected.OfType <PremiumJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return(false);
}
PremiumJournalNode selectedNode = selectedNodes.First();
if (selectedNode.EntityType == typeof(PremiumRaskatGAZelle))
{
return(false);
}
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanDelete);
},
(selected) => true,
(selected) =>
{
var selectedNodes = selected.OfType <PremiumJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return;
}
PremiumJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
if (config.PermissionResult.CanDelete)
{
DeleteHelper.DeleteEntity(selectedNode.EntityType, selectedNode.Id);
}
},
"Delete"
);
NodeActionsList.Add(deleteAction);
}
protected void CreateDeleteAction()
{
var deleteAction = new JournalAction("Удалить",
(selected) =>
{
var selectedNodes = selected.OfType <DeliveryPointJournalNode>().ToList();
if (!selectedNodes.Any())
{
return(false);
}
var selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanDelete && _canDeleteClientAndDp);
},
(selected) => true,
(selected) =>
{
var selectedNodes = selected.OfType <DeliveryPointJournalNode>().ToList();
if (!selectedNodes.Any())
{
return;
}
var selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
if (config.PermissionResult.CanDelete)
{
DeleteHelper.DeleteEntity(selectedNode.EntityType, selectedNode.Id);
}
},
"Delete"
);
NodeActionsList.Add(deleteAction);
}
private void CreateAddWriteoffItemCommand()
{
AddWriteoffItemCommand = new DelegateCommand(
() => {
var fuelTypeJournalViewModel = new SimpleEntityJournalViewModel <FuelType, FuelTypeViewModel>(x => x.Name,
() => new FuelTypeViewModel(EntityUoWBuilder.ForCreate(), unitOfWorkFactory, commonServices),
(node) => new FuelTypeViewModel(EntityUoWBuilder.ForOpen(node.Id), unitOfWorkFactory, commonServices),
QS.DomainModel.UoW.UnitOfWorkFactory.GetDefaultFactory,
commonServices
);
fuelTypeJournalViewModel.SetRestriction(() => {
return(Restrictions.Not(Restrictions.In(Projections.Id(), Entity.ObservableFuelWriteoffDocumentItems.Select(x => x.FuelType.Id).ToArray())));
});
fuelTypeJournalViewModel.SelectionMode = JournalSelectionMode.Single;
fuelTypeJournalViewModel.OnEntitySelectedResult += (sender, e) => {
var node = e.SelectedNodes.FirstOrDefault();
if (node == null)
{
return;
}
Entity.AddNewWriteoffItem(UoW.GetById <FuelType>(node.Id));
};
var fuelTypePermissionSet = commonServices.PermissionService.ValidateUserPermission(typeof(FuelType), commonServices.UserService.CurrentUserId);
if (fuelTypePermissionSet.CanRead && !fuelTypePermissionSet.CanUpdate)
{
var viewAction = new JournalAction("Просмотр",
(selected) => selected.Any(),
(selected) => true,
(selected) =>
{
var tab = fuelTypeJournalViewModel.GetTabToOpen(typeof(FuelType), selected.First().GetId());
fuelTypeJournalViewModel.TabParent.AddTab(tab, fuelTypeJournalViewModel);
}
);
(fuelTypeJournalViewModel.NodeActions as IList <IJournalAction>)?.Add(viewAction);
}
TabParent.AddSlaveTab(this, fuelTypeJournalViewModel);
},
() => CanEdit
);
AddWriteoffItemCommand.CanExecuteChangedWith(this, x => CanEdit);
}
protected override void CreatePopupActions()
{
base.CreatePopupActions();
var resetPassAction = new JournalAction(
"Сбросить пароль",
x => x.FirstOrDefault() != null,
x => true,
selectedItems =>
{
var selectedNodes = selectedItems.Cast <EmployeeJournalNode>();
var selectedNode = selectedNodes.FirstOrDefault();
if (selectedNode != null)
{
using (var uow = UnitOfWorkFactory.CreateWithoutRoot("Сброс пароля пользователю"))
{
var employee = uow.GetById <Employee>(selectedNode.Id);
if (employee.User == null)
{
commonServices.InteractiveService.ShowMessage(ImportanceLevel.Error,
"К сотруднику не привязан пользователь!");
return;
}
if (string.IsNullOrEmpty(employee.User.Login))
{
commonServices.InteractiveService.ShowMessage(ImportanceLevel.Error,
"У пользователя не заполнен логин!");
return;
}
if (commonServices.InteractiveService.Question("Вы уверены?"))
{
ResetPasswordForEmployee(employee);
}
}
}
});
PopupActionsList.Add(resetPassAction);
NodeActionsList.Add(resetPassAction);
}
protected virtual void CreateCustomSelectAction()
{
var selectAction = new JournalAction("Выбрать",
(selected) => selected.Any() && selected.All(x => (x as CounterpartyJournalNode).Sensitive),
(selected) => SelectionMode != JournalSelectionMode.None,
(selected) => { if (selected.All(x => (x as CounterpartyJournalNode).Sensitive))
{
OnItemsSelected(selected);
}
}
);
if (SelectionMode == JournalSelectionMode.Single || SelectionMode == JournalSelectionMode.Multiple)
{
RowActivatedAction = selectAction;
}
NodeActionsList.Add(selectAction);
}
private void CreateCustomAddActions()
{
var createAction = new JournalAction("Создать",
(selected) =>
{
var config = EntityConfigs[typeof(UndeliveredOrder)];
return(config.PermissionResult.CanCreate);
},
(selected) => true,
(selected) =>
{
var config = EntityConfigs[typeof(UndeliveredOrder)];
var foundDocumentConfig = config.EntityDocumentConfigurations.FirstOrDefault();
foundDocumentConfig?.GetCreateEntityDlgConfigs().FirstOrDefault()?.OpenEntityDialogFunction();
}
);
NodeActionsList.Add(createAction);
}
protected override void CreateNodeActions()
{
NodeActionsList.Clear();
_canEdit = CurrentPermissionService.ValidateEntityPermission(typeof(Payment)).CanUpdate;
var editAction = new JournalAction("Изменить",
(selected) => _canEdit && selected.Any(),
(selected) => VisibleEditAction,
(selected) => selected.OfType <UnallocatedBalancesJournalNode>().ToList().ForEach(EditEntityDialog)
);
NodeActionsList.Add(editAction);
if (SelectionMode == JournalSelectionMode.None)
{
RowActivatedAction = editAction;
}
}
protected void CreateDeleteAction()
{
var deleteAction = new JournalAction("Удалить",
(selected) => {
var selectedNodes = selected.OfType <DeliveryPointJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return(false);
}
DeliveryPointJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanDelete &&
commonServices.CurrentPermissionService.ValidatePresetPermission("can_delete_counterparty_and_deliverypoint"));
},
(selected) => true,
(selected) => {
var selectedNodes = selected.OfType <DeliveryPointJournalNode>();
if (selectedNodes == null || selectedNodes.Count() != 1)
{
return;
}
DeliveryPointJournalNode selectedNode = selectedNodes.First();
if (!EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
if (config.PermissionResult.CanDelete)
{
DeleteHelper.DeleteEntity(selectedNode.EntityType, selectedNode.Id);
}
}
);
NodeActionsList.Add(deleteAction);
}
private void CreateCustomEditAction()
{
var editAction = new JournalAction("Изменить",
(selected) =>
{
var selectedNodes = selected.OfType <UndeliveredOrderJournalNode>();
var selectedNode = selectedNodes.FirstOrDefault();
if (selectedNode == null || !EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return(false);
}
var config = EntityConfigs[selectedNode.EntityType];
return(config.PermissionResult.CanUpdate);
},
(selected) => true,
(selected) =>
{
var selectedNodes = selected.OfType <UndeliveredOrderJournalNode>();
var selectedNode = selectedNodes.FirstOrDefault();
if (selectedNode == null || !EntityConfigs.ContainsKey(selectedNode.EntityType))
{
return;
}
var config = EntityConfigs[selectedNode.EntityType];
var foundDocumentConfig = config.EntityDocumentConfigurations.FirstOrDefault(x => x.IsIdentified(selectedNode));
foundDocumentConfig?.GetOpenEntityDlgFunction().Invoke(selectedNode);
}
);
if (SelectionMode == JournalSelectionMode.None)
{
RowActivatedAction = editAction;
}
NodeActionsList.Add(editAction);
}
/// <summary>
/// Logs action to the journal with transaction.
/// </summary>
/// <param name="action">The action.</param>
/// <param name="xmlParams">Xml parameters.</param>
public void LogToJournalWithTransaction(JournalAction action, XDocument xmlParams)
{
SqlConnectionManager.Instance.BeginTransaction();
try
{
this.LogToJournal(action, xmlParams);
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:100");
SqlConnectionManager.Instance.RollbackTransaction();
if (sqle.Number == 1205)
{
throw new ClientException(ClientExceptionId.Deadlock, sqle);
}
else if (sqle.Number == 17142 || sqle.Number == 10054)
{
throw new ClientException(ClientExceptionId.SqlConnectionError);
}
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:101");
SqlConnectionManager.Instance.RollbackTransaction();
throw;
}
}
protected override void CreateNodeActions()
{
NodeActionsList.Clear();
var selectAction = new JournalAction("Выбрать",
(selected) => selected.Any() && selected.All(x => ((NomenclatureBalanceByStockJournalNode)x).NomenclatureAmount > 0),
(selected) => SelectionMode != JournalSelectionMode.None,
(selected) =>
{
if (selected.All(x => ((NomenclatureBalanceByStockJournalNode)x).NomenclatureAmount > 0))
{
OnItemsSelected(selected);
}
}
);
if (SelectionMode == JournalSelectionMode.Single || SelectionMode == JournalSelectionMode.Multiple)
{
RowActivatedAction = selectAction;
}
NodeActionsList.Add(selectAction);
}
private void CreateEditAction()
{
var editAction = new JournalAction("Открыть заказ",
(selected) => {
var selectedNodes = selected.OfType <DriverMessageJournalNode>();
return(selectedNodes.Count() == 1);
},
(selected) => true,
(selected) => {
var selectedNodes = selected.OfType <DriverMessageJournalNode>();
if (selectedNodes.Count() != 1)
{
return;
}
var selectedNode = selectedNodes.First();
_gtkTabsOpener.OpenOrderDlg(this, selectedNode.OrderId);
HideJournal();
}
);
RowActivatedAction = editAction;
NodeActionsList.Add(editAction);
}
protected override void CreateNodeActions()
{
_paymentPermissionResult = CurrentPermissionService.ValidateEntityPermission(typeof(Payment));
NodeActionsList.Clear();
CreateAddNewPaymentAction();
var addAction = new JournalAction("Добавить",
(selected) => _paymentPermissionResult.CanCreate,
(selected) => VisibleCreateAction,
(selected) => CreateEntityDialog(),
"Insert"
);
NodeActionsList.Add(addAction);
var editAction = new JournalAction("Изменить",
(selected) => _paymentPermissionResult.CanUpdate && selected.Any(),
(selected) => VisibleEditAction,
(selected) => selected.OfType <PaymentJournalNode>().ToList().ForEach(EditEntityDialog)
);
NodeActionsList.Add(editAction);
if (SelectionMode == JournalSelectionMode.None)
{
RowActivatedAction = editAction;
}
NodeActionsList.Add(new JournalAction(
"Завершить распределение",
x => true,
x => true,
selectedItems => CompleteAllocation()
)
);
}
