public ActionResult Execute(UI.Action action)
{
var searchFieldIds = action
.Parameters
.Where(p => p.ParameterType == ParameterType.AutoCompleteSearchFieldId)
.Select(p => Convert.ToInt32(p.DefaultValue))
.ToList();
var displayFieldIds = action
.Parameters
.Where(p => p.ParameterType == ParameterType.AutoCompleteDisplayFieldId)
.Select(p => Convert.ToInt32(p.DefaultValue))
.ToList();
var searchFields = DbEditorService.GetFields(searchFieldIds);
var displayFields = DbEditorService.GetFields(displayFieldIds);
var templateName = searchFields.First().Template.Name;
var result = DbDocumentService.GetDocuments(displayFields, searchFields, DAL.Models.OperationType.StartsWith, action.Value);
return(new ActionResult()
{
ActionType = action.ActionType,
Success = true,
Data = result
});
}
public ActionResult Execute(UI.Action action)
{
var view = action.ViewData;
var templateDef = DbEditorService.GetTemplate(Convert.ToInt32(view.Props["TemplateId"]));
var controls = new List <UI.Control>();
GetFlatListOfControls(action.ViewData, ref controls);
var dictionaryControls = controls.Where(c => c.ControlType.In(ControlType.MultiSelect, ControlType.Select));
var labelControls = controls.Where(c => c.ControlType.In(ControlType.Label));
var referenceControls = controls.Where(c => c.ControlType.In(ControlType.Table));
var dataControls = controls
.Except(dictionaryControls)
.Except(referenceControls)
.Except(labelControls);
var dataTableKeyValues = dataControls.Select(c => new KeyValuePair <string, object>((string)c.Props["Name"], c.Value)).ToList();
Dictionary <string, object> values = dataTableKeyValues.ToDictionary(kv => kv.Key, kv => kv.Value);
DbDocumentService.UpdateDocument(templateDef.Name, action.DocId.Value, values);
ProcessDictionaryControls(dictionaryControls);
return(new ActionResult()
{
ActionType = action.ActionType,
Success = true
});
}
public ActionResult Execute(UI.Action action)
{
var filters = action.ViewData.Filters;
var viewId = Convert.ToInt32(filters.First().Props["ViewId"]);
var dalViewDef = DbEditorService.GetViewDeep(viewId);
var viewBehaviour = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(dalViewDef.ViewType)](CurrentUser);
var pageNumParam = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.PageNumber);
var pageSizeParam = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.PageSize);
var sortFieldParam = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.SortFieldId);
var sortDirectionParam = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.SortDirection);
bool hasPageAndSortInfo = true;
if (string.IsNullOrEmpty(pageNumParam.DefaultValue) ||
string.IsNullOrEmpty(pageSizeParam.DefaultValue) ||
string.IsNullOrEmpty(sortFieldParam.DefaultValue) ||
string.IsNullOrEmpty(sortDirectionParam.DefaultValue))
{
hasPageAndSortInfo = false;
}
DAL.Models.DbSearchRequestParams sortAndPageParams = DAL.Models.DbSearchRequestParams.GetDefault(dalViewDef);
if (hasPageAndSortInfo)
{
var pageNum = Convert.ToInt32(pageNumParam.DefaultValue);
var pageSize = Convert.ToInt32(pageSizeParam.DefaultValue);
var sortFieldId = Convert.ToInt32(sortFieldParam.DefaultValue);
var sortDir = sortDirectionParam.DefaultValue;
var sortField = DbEditorService.GetField(sortFieldId);
sortAndPageParams = new DAL.Models.DbSearchRequestParams(pageNum, pageSize, sortField, sortDir);
}
var ticketSet = DbDocumentService.GetDocuments(dalViewDef, filters.Select(f => (IFilterWithValue)f).ToList(), sortAndPageParams);
var viewDef = Mapper.Map <UI.ViewDefinition>(dalViewDef);
var view = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(viewDef.ViewType)](CurrentUser).Make(viewDef, ticketSet, null, null);
return(new ActionResult()
{
Success = true,
ActionType = action.ActionType,
Data = view
});
}
public ActionResult Execute(UI.Action action)
{
Parameter templateParam = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.TemplateId);
if (templateParam == null)
{
throw new CustomValidationException($"There is no TemplateId parameter for action DeleteDocument.");
}
int templateId = Convert.ToInt32(templateParam.DefaultValue);
DAL.Models.Template templateDef = DbEditorService.GetTemplate(templateId);
DbDocumentService.UpdateDocumentToDeleted(templateDef.Name, action.DocId.Value);
return(new ActionResult()
{
ActionType = action.ActionType,
Success = true
});
}
public ActionResult Execute(UI.Action action)
{
var filterIdParameter = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.FilterId);
var dbFilterDef = DbEditorService.GetFilter(Convert.ToInt32(filterIdParameter.DefaultValue));
if (dbFilterDef == null)
{
throw new CustomValidationException("Filter is not defined for this action.");
}
var filterDef = Mapper.Map <UI.FilterDefinition>(dbFilterDef);
var filter = BehaviourSelector.FilterBehaviours[Mapper.Map <UI.FilterType>(filterDef.FilterType)](CurrentUser).Make(filterDef, null);
var dbViewDef = DbEditorService.GetViewDeep(filterDef.ViewId);
var filterValues = new Dictionary <DAL.Models.Filter, object>()
{
{ dbFilterDef, null }
};
var searchParams = DAL.Models.DbSearchRequestParams.GetDefault(dbViewDef);
var tickets = DbDocumentService.GetDocuments(dbViewDef, new List <IFilterWithValue>()
{
filter
}, searchParams);
var viewDef = Mapper.Map <UI.ViewDefinition>(dbViewDef);
var view = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(viewDef.ViewType)](CurrentUser).Make(viewDef, tickets, null, null);
var result = new ActionResult()
{
Success = true,
ActionType = action.ActionType,
Data = view
};
return(result);
}
public View Make(ViewDefinition definition, DAL.Models.DbSearchResponse ticketSet, View parentNode, Action <UI.View> viewAction)
{
var view = new View()
{
ViewType = Mapper.Map <UI.ViewType>(definition.ViewType),
ParentNode = parentNode
};
var ticket = ticketSet.Tickets.FirstOrDefault();
// TODO
//view.DocId = (ticket != null) ? (int?)Convert.ToInt32(ticket["Id"]) : null;
view.Props = new Dictionary <string, object>()
{
{ "Name", definition.Name },
{ "TemplateId", definition.TemplateId },
{ "OrderIndex", definition.OrderIndex },
{ "DisplayName", definition.DisplayName },
{ "GridWidth", definition.GridWidth },
{ "LinkedFieldId", definition.LinkedFieldId },
{ "Active", false }
};
view.Controls = definition
.Controls
.Select(c => BehaviourSelector.ControlBehaviours[Mapper.Map <UI.ControlType>(c.ControlType)](CurrentUser).Make(c, ticketSet, view, null))
.ToList();
view.Filters = definition
.Filters
.Select(f => BehaviourSelector.FilterBehaviours[Mapper.Map <UI.FilterType>(f.FilterType)](CurrentUser).Make(f, view))
.ToList();
foreach (var childViewDef in definition.ChildViews)
{
View childView;
if (childViewDef.ViewType == DAL.Models.ViewType.Table)
{
var parentFilters = ticketSet.Request.Filters;
var searchParams = DAL.Models.DbSearchRequestParams.GetDefault((DAL.Models.View)childViewDef.Entity);
searchParams.SearchWithInnerJoin = true;
var linkedTickets = DbDocumentService.GetDocuments((DAL.Models.View)childViewDef.Entity, parentFilters, searchParams);
childView = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(childViewDef.ViewType)](CurrentUser)
.Make(childViewDef, linkedTickets, null, null);
}
else
{
childView = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(childViewDef.ViewType)](CurrentUser)
.Make(childViewDef, ticketSet, null, null);
}
view.ChildViews.Add(childView);
}
if (definition.ChildViews.Any(cv => cv.ViewType == DAL.Models.ViewType.Tab))
{
var parentView = new View()
{
ViewType = ViewType.TabContainer,
ParentNode = parentNode
};
var tabViews = view.ChildViews.Where(v => v.ViewType == ViewType.Tab);
view.ChildViews = view.ChildViews.Except(tabViews).ToList();
view.ViewType = ViewType.Tab;
view.ParentNode = parentView;
view.Props["Active"] = true;
parentView.DocId = view.DocId;
parentView.Props = view.Props;
parentView.ChildViews.AddRange((new List <View>()
{
view
}).Union(tabViews));
return(parentView);
}
else
{
return(view);
}
}
public async Task CreateCompany_Should_CreateCompany()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var mediatorMock = new Mock <IPublisher>();
var fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
// var dbFieldMetadataRepository = new DbFieldMetadataRepository(dbContextFactory, fieldProviderRegistry, new NewtonsoftJsonSerializer());
var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var dbNumberGenerator = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, Array.Empty <INumberTagResolver>());
var dbDocumentService = new DbDocumentService(dbContextFactory, dbNumberGenerator, mediatorMock.Object);
var jsonSerializer = new DefaultJsonSerializer();
var auditLogService = new DbAuditLogService(dbContextFactory, jsonSerializer);
var classifierRegistrator = new DefaultClassifierRegistrator(NullLogger <DefaultClassifierRegistrator> .Instance, classifierRepositoryFactory);
var metadataRepositoryMock = new Mock <IRepository <FieldMetadata> >();
metadataRepositoryMock
.Setup(x => x.Search(It.IsAny <MetadataSearchRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new SearchResult <FieldMetadata>
{
Rows = new FieldMetadata[]
{
new TextField {
Key = "test1", Active = true, System = false
},
new TextField {
Key = "test2", Active = true, System = false
},
new TextField {
Key = "test3", Active = true, System = false
}
}
});
var backgroundJobManagerMock = new Mock <IBackgroundJobManager>();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new CreateCompanyHandler(unitOfWorkFactory,
dbContextFactory, dateTimeProvider, metadataRepositoryMock.Object,
dbFieldDataRepository, classifierRepositoryFactory, dbDocumentService, auditLogService, backgroundJobManagerMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
await generator.EnsureClassifierTypeRegistered(Numerator.GetDefaultMetadata(), cancellationToken);
await generator.EnsureClassifierTypeRegistered(DocumentType.GetDefaultMetadata(), cancellationToken);
foreach (var classifier in RegisterClassifiersStartupTask.GetClassifiers())
{
await classifierRegistrator.Register(classifier, cancellationToken);
}
// act
var company = new Company
{
ConfigCode = "company",
Name = "Montr Inc.",
Fields = new FieldData
{
{ "test1", "value1" },
{ "test2", "value2" },
{ "test3", "value3" }
}
};
var command = new CreateCompany
{
UserUid = Guid.NewGuid(),
Item = company
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Uid);
Assert.AreNotEqual(Guid.Empty, result.Uid);
// assert registration request inserted
DbDocument dbDocument;
using (var db = dbContextFactory.Create())
{
dbDocument = await db.GetTable <DbDocument>()
.Where(x => x.CompanyUid == result.Uid)
.SingleAsync(cancellationToken);
}
Assert.IsNotNull(dbDocument);
// assert registration request field data inserted
IList <DbFieldData> fieldData;
using (var db = dbContextFactory.Create())
{
fieldData = await db.GetTable <DbFieldData>()
.Where(x => x.EntityTypeCode == Document.TypeCode && x.EntityUid == dbDocument.Uid)
.ToListAsync(cancellationToken);
}
Assert.AreEqual(company.Fields.Count, fieldData.Count);
Assert.AreEqual(company.Fields["test1"], fieldData.Single(x => x.Key == "test1").Value);
Assert.AreEqual(company.Fields["test2"], fieldData.Single(x => x.Key == "test2").Value);
Assert.AreEqual(company.Fields["test3"], fieldData.Single(x => x.Key == "test3").Value);
}
}
public ActionResult Execute(UI.Action action)
{
if (action.DocId == null)
{
throw new CustomValidationException("DocId not defined for action's parent control. Please assign Id field to control.");
}
var viewIdParameter = action.Parameters.FirstOrDefault(p => p.ParameterType == UI.ParameterType.ViewId);
var anchorParameter = action.Parameters.FirstOrDefault(p => p.ParameterType == UI.ParameterType.ViewAnchor);
var dbViewDef = DbEditorService.GetViewDeep(Convert.ToInt32(viewIdParameter.DefaultValue));
var viewDef = Mapper.Map <ViewDefinition>(dbViewDef);
var fieldId = Convert.ToInt32(action.Props["FieldId"]);
var field = DbEditorService.GetField(fieldId);
var filter = new VirtualFilter()
{
Operation = DAL.Models.OperationType.EqualTo,
ViewId = dbViewDef.Id
};
filter.FilterFields = new List <IFilterField>()
{
new VirtualFilterField()
{
ChainId = 0, Depth = 0, Filter = filter, Field = field
}
};
var filterWithValue = new VirtualFilterWithValue()
{
Filter = filter, Value = action.DocId
};
var searchParams = DAL.Models.DbSearchRequestParams.GetDefault(dbViewDef);
var ticketSet = DbDocumentService.GetDocuments(dbViewDef, new List <IFilterWithValue>()
{
filterWithValue
}, searchParams);
UI.View view;
if (ticketSet.Tickets.Count == 1)
{
view = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(dbViewDef.ViewType)](CurrentUser)
.Make(viewDef, ticketSet, null, null);
var views = GetFlatListOfViews(view);
if (anchorParameter != null && views.Count > 0)
{
foreach (var v in views)
{
if (v.Props.ContainsKey("Active"))
{
v.Props["Active"] = (v.Definition?.Id == Convert.ToInt32(anchorParameter.DefaultValue));
}
}
}
}
else
{
throw new CustomValidationException("Applying filters in goto action does not result in a single document.");
}
var result = new ActionResult()
{
Success = true,
ActionType = action.ActionType,
Data = view
};
return(result);
}
public ActionResult Execute(UI.Action action)
{
// Создаваемый шаблон
var tempIdParam = action.Parameters.FirstOrDefault(p => p.ParameterType == UI.ParameterType.TemplateId);
if (tempIdParam == null)
{
throw new CustomValidationException($"TemplateId parameter missing for action {action.Props["Id"]}.");
}
// Получаем модель шаблона по которой будем создавать документ
var templateDef = DbEditorService.GetTemplate(Convert.ToInt32(tempIdParam.DefaultValue));
// Создаем значения по умолчанию, которыми будет заполнен новый документ
var values = templateDef.Fields
.Select(f => new KeyValuePair <DAL.Models.Field, object>(f, null))
.ToDictionary(kv => kv.Key, kv => kv.Value);
// Проверяем есть ли параметры копирования значений в новый шаблон
FillValues(action, templateDef, values);
// Создаем документ шаблона и получаем его ID
var docId = DbDocumentService.CreateDocument(values);
// Страницу на которую мы перейдем и в которой будет созданный документ по шаблону
var viewIdParam = action.Parameters.FirstOrDefault(p => p.ParameterType == UI.ParameterType.ViewId);
// Проверка параметров
if (viewIdParam != null)
{
// Проверяем есть ли на странице фильтр с помощью которого мы попадем на нее
var viewDefDal = DbEditorService.GetViewDeep(Convert.ToInt32(viewIdParam.DefaultValue));
var filterDefDal = viewDefDal.Filters.FirstOrDefault();
if (filterDefDal == null)
{
throw new CustomValidationException($"View {viewDefDal.Id} must have a filter defined.");
}
// Создаем фильтр поля ID с помощью которого мы откроем страницу которая привязана к созданному документу
// Заполняем его значением созданного документа
var filterDef = Mapper.Map <UI.FilterDefinition>(filterDefDal);
var filter = BehaviourSelector.FilterBehaviours[Mapper.Map <UI.FilterType>(filterDef.FilterType)](CurrentUser).Make(filterDef, null);
filter.Value = docId;
// Ищем только что созданный документ по фильтру и открываем страницу с привязкой к этому документу
var searchParams = DAL.Models.DbSearchRequestParams.GetDefault(viewDefDal);
var ticketSet = DbDocumentService.GetDocuments(viewDefDal, new List <DAL.Interfaces.IFilterWithValue>()
{
filter
}, searchParams);
var viewDef = Mapper.Map <UI.ViewDefinition>(viewDefDal);
var view = BehaviourSelector.ViewBehaviours[Mapper.Map <UI.ViewType>(viewDef.ViewType)](CurrentUser).Make(viewDef, ticketSet, null, null);
// Возвращаем страницу в качестве результата
return(new ActionResult()
{
ActionType = action.ActionType,
Data = view,
Success = true
});
}
else
{
return(new ActionResult()
{
ActionType = action.ActionType,
Success = true
});
}
}
private static void FillValues(UI.Action action, DAL.Models.Template templateDef, Dictionary <DAL.Models.Field, object> values)
{
List <Parameter> copyParameters = action.Parameters
.FindAll(p => p.ParameterType == UI.ParameterType.CopyValueFrom || p.ParameterType == UI.ParameterType.CopyValueTo);
if (copyParameters.Count > 0)
{
if (!copyParameters.All(p => p.Props.ContainsKey("Name") && !string.IsNullOrEmpty((string)p.Props["Name"])))
{
throw new CustomValidationException($"All CopyParameters have to contain a Name property. ActionId={action.Definition.Id}");
}
if (!copyParameters.Where(p => p.ParameterType == ParameterType.CopyValueTo).All(p => p.Props.ContainsKey("FieldId")))
{
throw new CustomValidationException($"All CopyParameters.Destination have to contain a FieldId property. ActionId={action.Definition.Id}");
}
// Создаем набор параметров из списка двух типов параметров
List <Incoming.CopyFieldParameter> prms = copyParameters.GroupBy(p => (string)p.Props["Name"]).Select(g =>
{
if (g.Count() != 2)
{
throw new CustomValidationException($"There is no pair for parameter: {g.Key}");
}
Parameter paramFrom = g.FirstOrDefault(p => p.ParameterType == ParameterType.CopyValueFrom);
Parameter paramTo = g.FirstOrDefault(p => p.ParameterType == ParameterType.CopyValueTo);
paramFrom.Props.Where(p => p.Value == null).ToList().ForEach(p => paramFrom.Props.Remove(p.Key));
paramTo.Props.Where(p => p.Value == null).ToList().ForEach(p => paramTo.Props.Remove(p.Key));
int fieldFromId = paramFrom.Props.ContainsKey("FieldId") ? Convert.ToInt32(paramFrom.Props["FieldId"]) : 0;
int fieldToId = paramTo.Props.ContainsKey("FieldId") ? Convert.ToInt32(paramTo.Props["FieldId"]) : 0;
Incoming.CopyFieldParameter paramCopy = new Incoming.CopyFieldParameter()
{
DefaultValue = paramFrom.DefaultValue,
FieldFromId = fieldFromId,
FieldToId = fieldToId
};
return(paramCopy);
}).ToList();
// Заполняем значениями по умолчанию
foreach (var param in prms.Where(p => p.FieldToId > 0 && p.DefaultValue != null))
{
DAL.Models.Field templateDefField = templateDef.Fields.FirstOrDefault(f => f.Id == param.FieldToId);
if (templateDefField == null)
{
throw new CustomValidationException($"Destination template missing field id={param.FieldToId}.");
}
values.Add(templateDefField, param.DefaultValue);
}
// Заполняем значениями документа из которого был создан новый документ
// Определяем шаблон источника
int fieldId = prms.FirstOrDefault(p => p.FieldFromId > 0)?.FieldFromId ?? 0;
if (fieldId > 0)
{
DbEditorService editor = new DbEditorService();
DAL.Models.Field field = editor.GetField(fieldId);
DAL.Models.Template templateDefFrom = DbEditorService.GetTemplate(field.TemplateId);
int parentDocId = Convert.ToInt32(action.DocId);
Dictionary <string, object> documentFrom = DbDocumentService.GetDocument(templateDefFrom.Name, parentDocId);
foreach (var param in prms.Where(p => p.FieldFromId > 0))
{
DAL.Models.Field fieldFrom = templateDefFrom.Fields.FirstOrDefault(f => f.Id == param.FieldFromId);
DAL.Models.Field fieldTo = templateDef.Fields.FirstOrDefault(f => f.Id == param.FieldToId);
values.Add(fieldTo, documentFrom[fieldFrom.Name]);
}
}
}
}
static Service()
{
DbDocService = new DbDocumentService();
DbEditorService = new DbEditorService();
DbDictionaryCache = new DbDictionaryCache();
}
