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 UI.ViewDefinition CreateView(UI.ViewDefinition view)
{
var dalView = DbEditorService.CreateView(Mapper.Map <DAL.Models.View>(view), CurrentUser.Login);
if (view.Controls != null)
{
foreach (var control in view.Controls)
{
var dalControl = DbEditorService.CreateControl(Mapper.Map <DAL.Models.Control>(control));
dalView.Controls.Add(dalControl);
}
}
var newView = Mapper.Map <UI.ViewDefinition>(dalView);
if (view.ChildViews != null)
{
for (var i = 0; i < view.ChildViews.Count; i++)
{
var subView = CreateView(view.ChildViews[i]);
newView.ChildViews.Add(subView);
}
}
return(newView);
}
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 List <Incoming.Document> GetDocumentsByParameter(int templateId, string paramName, object paramValue)
{
var template = DbEditorService.GetTemplate(templateId);
if (template == null)
{
throw new CustomValidationException($"Template not found for id:{templateId}");
}
var searchResult = DbDocService.GetDocumentsByParameter(template.Name, paramName, paramValue);
if (searchResult == null)
{
throw new CustomValidationException($"Result is null for id:{templateId}, pararmName:{paramName}, paramValue:{paramValue}");
}
var result = searchResult.Select(values =>
new Incoming.Document()
{
TemplateId = templateId,
Values = values
}).ToList();
return(result);
}
public UI.TemplateDefinition GetTemplate(int id)
{
var dbTemplate = DbEditorService.GetTemplate(id);
var template = Mapper.Map <UI.TemplateDefinition>(dbTemplate);
return(template);
}
public UI.TemplateDefinition UpdateTemplate(UI.TemplateDefinition template)
{
var dbTemplate = Mapper.Map <DAL.Models.Template>(template);
dbTemplate = DbEditorService.UpdateTemplate(dbTemplate);
return(Mapper.Map <UI.TemplateDefinition>(dbTemplate));
}
public List <UI.UserDefinition> FindUsersByLogin(string login)
{
var dbUsers = DbEditorService.FindUsersByLogin(login);
var users = dbUsers.Select(dbUser => Mapper.Map <UI.UserDefinition>(dbUser)).ToList();
return(users);
}
public UI.FieldDefinition CreateField(UI.FieldDefinition field)
{
var dbField = Mapper.Map <DAL.Models.Field>(field);
dbField = DbEditorService.CreateField(dbField);
return(Mapper.Map <UI.FieldDefinition>(dbField));
}
public UI.FilterDefinition UpdateFilter(UI.FilterDefinition filter)
{
var dbFilter = Mapper.Map <DAL.Models.Filter>(filter);
dbFilter = DbEditorService.UpdateFilter(dbFilter);
return(Mapper.Map <UI.FilterDefinition>(dbFilter));
}
public StyleDefinition UpdateStyle(StyleDefinition style)
{
var dbStyle = Mapper.Map <DAL.Models.Style>(style);
dbStyle = DbEditorService.UpdateStyle(dbStyle);
return(Mapper.Map <UI.StyleDefinition>(dbStyle));
}
public UserRoleDefinition AddUserToRole(UserRoleDefinition userRole)
{
var dalUserRole = Mapper.Map <DAL.Models.UserRole>(userRole);
var newUserRole = DbEditorService.AddUserToRole(dalUserRole, CurrentUser.Login);
return(Mapper.Map <UI.UserRoleDefinition>(newUserRole));
}
public UI.ControlDefinition UpdateControl(UI.ControlDefinition control)
{
var dbControl = Mapper.Map <DAL.Models.Control>(control);
dbControl = DbEditorService.UpdateControl(dbControl);
return(Mapper.Map <UI.ControlDefinition>(dbControl));
}
public PermissionDefinition AddPermissionToRole(PermissionDefinition permission)
{
var dalPermission = Mapper.Map <DAL.Models.Permission>(permission);
var newPermission = DbEditorService.AddPermissionToRole(dalPermission, CurrentUser.Login);
return(Mapper.Map <UI.PermissionDefinition>(newPermission));
}
public UI.ViewDefinition UpdateView(UI.ViewDefinition view)
{
var dbView = Mapper.Map <DAL.Models.View>(view);
dbView = DbEditorService.UpdateView(dbView);
return(Mapper.Map <UI.ViewDefinition>(dbView));
}
public RoleDefinition CreateRoleWithSectionId(RoleDefinition role, int sectionId)
{
var dalRole = Mapper.Map <DAL.Models.Role>(role);
var newRole = DbEditorService.CreateRoleWithSectionId(dalRole, sectionId);
return(Mapper.Map <UI.RoleDefinition>(newRole));
}
public UI.FieldDefinition CreateReferenceField(UI.FieldDefinition fieldA, UI.FieldDefinition fieldB)
{
var dbField1 = Mapper.Map <DAL.Models.Field>(fieldA);
var dbField2 = Mapper.Map <DAL.Models.Field>(fieldB);
var newField = DbEditorService.CreateReferenceField(dbField1, dbField2);
return(Mapper.Map <UI.FieldDefinition>(newField));
}
public List <Section> GetSections()
{
var defs = DbEditorService
.GetSections(CurrentUser.Login)
.Select(s => Mapper.Map <SectionDefinition>(s)).ToList();
var sections = defs.Select(def => BehaviourSelector.SectionBehaviours[SectionType.Default](CurrentUser).Make(def)).ToList();
return(sections);
}
public void DeleteDocument(int templateId, int docId)
{
var template = DbEditorService.GetTemplate(templateId);
if (template == null)
{
throw new CustomValidationException($"Template not found for id {templateId}");
}
DbDocService.DeleteDocument(template, docId);
}
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 void DeleteDictionaryRecord(int dictId, string key)
{
var dictDef = DbEditorService.GetDictionary(dictId);
if (dictDef.DictionaryType == DAL.Models.DictionaryType.Int)
{
DbDictionaryCache.DeleteDictionaryRecord(dictDef, Convert.ToInt32(key));
}
else
{
DbDictionaryCache.DeleteDictionaryRecord(dictDef, key);
}
}
public void UpdateDictionaryRecord(DictionaryRecord record)
{
var dictDef = DbEditorService.GetDictionary(record.DictionaryId);
if (dictDef.DictionaryType == DAL.Models.DictionaryType.Int)
{
DbDictionaryCache.UpdateDictionaryRecord(dictDef, Convert.ToInt32(record.Key), record.Description);
}
else
{
DbDictionaryCache.UpdateDictionaryRecord(dictDef, record.Key, record.Description);
}
}
public int CreateDocument(Incoming.Document document)
{
var template = DbEditorService.GetTemplate(document.TemplateId);
if (template == null)
{
throw new CustomValidationException($"Template not found for id {document.TemplateId}");
}
var values = template.Fields
.Select(f => new KeyValuePair <DAL.Models.Field, object>(f, document.Values[f.Name]))
.ToDictionary(kv => kv.Key, kv => kv.Value);
return(DbDocService.CreateDocument(values));
}
//public int CreateDocumentWithLink(Incoming.DocumentWithLink documentWithLink)
//{
// var document = documentWithLink.Document;
// var template = DbEditorService.GetTemplate(document.TemplateId);
// if (template == null)
// throw new CustomValidationException($"Template not found for id {document.TemplateId}");
// var docId = DbDocService.CreateDocument(template, document.Values);
// DbDocService.CreateLink(documentWithLink.FieldId, documentWithLink.ParentDocId, docId);
// return docId;
//}
public Incoming.Document GetDocument(int templateId, int docId)
{
var template = DbEditorService.GetTemplate(templateId);
if (template == null)
{
throw new CustomValidationException($"Template not found for id {templateId}");
}
var doc = new Incoming.Document()
{
TemplateId = templateId,
Values = DbDocService.GetDocument(template.Name, docId)
};
return(doc);
}
public UI.UserDefinition GetOrCreateUser(string login)
{
var existingUser = DbEditorService.GetUserByLogin(login);
if (existingUser == null)
{
var newDbUser = DbEditorService.CreateUser(new DAL.Models.User()
{
Login = login
});
return(Mapper.Map <UI.UserDefinition>(newDbUser));
}
else
{
return(Mapper.Map <UI.UserDefinition>(existingUser));
}
}
public List <DictionaryRecord> GetDictionaryRecords(int dictId)
{
var dictDef = DbEditorService.GetDictionary(dictId);
var list = new List <DictionaryRecord>();
var records = DbDictionaryCache.GetDictionaryRecords(dictDef);
foreach (var rec in records.Select(r => r))
{
list.Add(new DictionaryRecord()
{
DictionaryId = dictDef.Id, Key = rec.Key.ToString(), Description = rec.Value
});
}
return(list);
}
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 sectionIdStr = action.Parameters.FirstOrDefault(p => p.ParameterType == ParameterType.SectionId).DefaultValue;
var sectionId = Convert.ToInt32(sectionIdStr);
var dbRoles = DbEditorService.GetRolesBySectionId(sectionId);
for (var i = 0; i < dbRoles.Count; i++)
{
var irrelevantPermissions = dbRoles[i].Permissions.Where(p => p.View.ParentView != null).ToList();
for (var ii = 0; ii < irrelevantPermissions.Count(); ii++)
{
dbRoles[i].Permissions.Remove(irrelevantPermissions[ii]);
}
}
var roles = dbRoles.Select(r =>
{
var ur = DbEditorService.GetUserRole(r.Id, CurrentUser.Id);
var roleDef = Mapper.Map <UI.RoleDefinition>(r);
roleDef.CanBeEditedByCurrentUser = ur?.UserCanChangeRole ?? false;
return(roleDef);
}).ToList();
var view = new SectionSettingsViewBehaviour(CurrentUser).Make(null, null, null, (v) =>
{
v.Props.Add("Roles", roles.ToList());
v.Props.Add("SectionId", sectionId);
});
return(new ActionResult()
{
Success = true,
ActionType = ActionType.GetSectionSettings,
Data = view
});
}
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 List <UI.DictionaryDefinition> GetDictionaries()
{
var dbDicts = DbEditorService.GetDictionaries();
return(dbDicts.Select(d => Mapper.Map <UI.DictionaryDefinition>(d)).ToList());
}
public void DeleteField(int id)
{
DbEditorService.DeleteField(id);
}
