/// <summary>
/// Get default embedded resource file for a specified role
/// </summary>
/// <param name="role">RoleFilter</param>
/// <returns></returns>
private static string GetDefaultRoleFile(RoleFilter role)
{
if ((role & (role - 1)) != 0)
{
throw new ArgumentException("More than one flag set on role");
}
switch (role)
{
case RoleFilter.Unknown:
return("Xbim.COBieLiteUK.FilterHelper.COBieDefaultFilters.config");
case RoleFilter.Architectural:
return("Xbim.COBieLiteUK.FilterHelper.COBieArchitecturalFilters.config");
case RoleFilter.Mechanical:
return("Xbim.COBieLiteUK.FilterHelper.COBieMechanicalFilters.config");
case RoleFilter.Electrical:
return("Xbim.COBieLiteUK.FilterHelper.COBieElectricalFilters.config");
case RoleFilter.Plumbing:
return("Xbim.COBieLiteUK.FilterHelper.COBiePlumbingFilters.config");
case RoleFilter.FireProtection:
return("Xbim.COBieLiteUK.FilterHelper.COBieFireProtectionFilters.config");
default:
return(string.Empty);
}
}
/// <summary>
/// Get the file to roles information
/// </summary>
/// <returns>Dictionary or FileInfo to RoleFilter</returns>
private Dictionary <XbimModel, RoleFilter> GetFileRoles()
{
Dictionary <XbimModel, RoleFilter> modelRoles = new Dictionary <XbimModel, RoleFilter>();
foreach (var refModel in _fedModel.ReferencedModels)
{
IfcDocumentInformation doc = refModel.DocumentInformation;
IfcOrganization owner = doc.DocumentOwner as IfcOrganization;
if ((owner != null) && (owner.Roles != null))
{
RoleFilter docRoles = GetRoleFilters(owner.Roles.ToList());
try
{
FileInfo file = new FileInfo(refModel.Model.DatabaseName);
if (file.Exists)
{
modelRoles[refModel.Model] = docRoles;
}
else
{
MessageBox.Show("File path does not exist: {0}", doc.Name);
}
}
catch (System.ArgumentException)
{
MessageBox.Show("File path is incorrect: {0}", doc.Name);
}
}
}
return(modelRoles);
}
/// <summary>
/// Add the refrence models
/// </summary>
/// <param name="file">FileInfo for the xbimf file</param>
/// <param name="organizationName">Organisation Name</param>
/// <param name="role">RoleFilter</param>
/// <param name="displayName"></param>
public void AddRefModel(FileInfo file, string organizationName, RoleFilter roles = RoleFilter.Unknown, string displayName = null)
{
if (!file.Exists)
{
throw new FileNotFoundException("Cannot find reference model file", file.FullName);
}
//add model to list of referenced models
IfcIdentifier docId = _fedModel.AddModelReference(file.FullName, organizationName, IfcRole.UserDefined).Identifier;
using (var txn = _fedModel.BeginTransaction())
{
IfcDocumentInformation addDocId = _fedModel.ReferencedModels.Where(item => item.DocumentInformation.DocumentId == docId).Select(item => item.DocumentInformation).FirstOrDefault();
IfcOrganization org = addDocId.DocumentOwner as IfcOrganization;
if (org != null)
{
org.Roles.Clear();
//Add Roles
foreach (var item in GetActorRoles(roles))
{
org.AddRole(item);
}
}
//add display name if required
if (displayName != null)
{
addDocId.Description = displayName;
}
txn.Commit();
}
}
public async Task <List <WorkflowStep_RoleDTO> > SingleListRole([FromBody] WorkflowStep_RoleFilterDTO WorkflowStep_RoleFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
RoleFilter RoleFilter = new RoleFilter();
RoleFilter.Skip = 0;
RoleFilter.Take = 20;
RoleFilter.OrderBy = RoleOrder.Id;
RoleFilter.OrderType = OrderType.ASC;
RoleFilter.Selects = RoleSelect.ALL;
RoleFilter.Id = WorkflowStep_RoleFilterDTO.Id;
RoleFilter.Code = WorkflowStep_RoleFilterDTO.Code;
RoleFilter.Name = WorkflowStep_RoleFilterDTO.Name;
RoleFilter.StatusId = WorkflowStep_RoleFilterDTO.StatusId;
List <Role> Roles = await RoleService.List(RoleFilter);
List <WorkflowStep_RoleDTO> WorkflowStep_RoleDTOs = Roles
.Select(x => new WorkflowStep_RoleDTO(x)).ToList();
return(WorkflowStep_RoleDTOs);
}
public async Task <bool> ValidateName(Role Role)
{
if (string.IsNullOrWhiteSpace(Role.Name))
{
Role.AddError(nameof(RoleValidator), nameof(Role.Name), ErrorCode.NameEmpty);
}
else
{
if (Role.Name.Length > 255)
{
Role.AddError(nameof(RoleValidator), nameof(Role.Name), ErrorCode.NameOverLength);
}
RoleFilter RoleFilter = new RoleFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = Role.Id
},
Name = new StringFilter {
Equal = Role.Name
},
Selects = RoleSelect.Name
};
int count = await UOW.RoleRepository.Count(RoleFilter);
if (count != 0)
{
Role.AddError(nameof(RoleValidator), nameof(Role.Name), ErrorCode.NameExisted);
}
}
return(Role.IsValidated);
}
public async Task <bool> BulkDelete(List <Role> Roles)
{
RoleFilter RoleFilter = new RoleFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = Roles.Select(a => a.Id).ToList()
},
Selects = RoleSelect.Id
};
var listInDB = await UOW.RoleRepository.List(RoleFilter);
var listExcept = Roles.Except(listInDB);
if (listExcept == null || listExcept.Count() == 0)
{
return(true);
}
foreach (var Role in listExcept)
{
Role.AddError(nameof(RoleValidator), nameof(Role.Id), ErrorCode.IdNotExisted);
}
return(false);
}
public async Task <dynamic> DeletedFirstOrDefault([FromUri] RoleFilter filter)
{
filter = filter ?? new RoleFilter();
var result = await _sqlData.Role.DeletedFirstOrDefault(filter);
return(new { Result = JsonConvert.DeserializeObject(result) });
}
/// <summary>
/// Get ActorRoles mapped to roles held in RoleFilter Flags
/// </summary>
/// <param name="role">RoleFilter</param>
/// <returns>List of IfcActorRole</returns>
private List <IfcActorRole> GetActorRoles(RoleFilter role)
{
if (RoleMap == null)
{
RoleMap = new Dictionary <RoleFilter, IfcActorRole>();
}
List <IfcActorRole> actorRoles = new List <IfcActorRole>();
if (role.HasFlag(RoleFilter.Architectural))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Architectural) ? RoleMap[RoleFilter.Architectural] : MapRole(RoleFilter.Architectural, IfcRole.Architect));
}
if (role.HasFlag(RoleFilter.Mechanical))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Mechanical) ? RoleMap[RoleFilter.Mechanical] : MapRole(RoleFilter.Mechanical, IfcRole.MechanicalEngineer));
}
if (role.HasFlag(RoleFilter.Electrical))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Electrical) ? RoleMap[RoleFilter.Electrical] : MapRole(RoleFilter.Electrical, IfcRole.ElectricalEngineer));
}
if (role.HasFlag(RoleFilter.Plumbing))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Plumbing) ? RoleMap[RoleFilter.Plumbing] : MapRole(RoleFilter.Plumbing, IfcRole.UserDefined));
}
if (role.HasFlag(RoleFilter.FireProtection))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.FireProtection) ? RoleMap[RoleFilter.FireProtection] : MapRole(RoleFilter.FireProtection, IfcRole.UserDefined));
}
if (role.HasFlag(RoleFilter.Unknown))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Unknown) ? RoleMap[RoleFilter.Unknown] : MapRole(RoleFilter.Unknown, IfcRole.UserDefined));
}
return(actorRoles);
}
public void IfcToCoBieLiteUkTest()
{
const string ifcTestFile = @"Lakeside_Restaurant.ifc";
using (var m = IfcStore.Open(ifcTestFile))
{
var jsonFile = Path.ChangeExtension(ifcTestFile, "json");
var facilities = new List <Facility>();
var rolefilters = new OutPutFilters();
const RoleFilter reqRoles = RoleFilter.Unknown; //RoleFilter.Architectural | RoleFilter.Mechanical | RoleFilter.Electrical | RoleFilter.FireProtection | RoleFilter.Plumbing;
rolefilters.ApplyRoleFilters(reqRoles);
var ifcToCoBieLiteUkExchanger = new IfcToCOBieLiteUkExchanger(m, facilities, null, rolefilters);
facilities = ifcToCoBieLiteUkExchanger.Convert();
foreach (var facilityType in facilities)
{
var log = new StringWriter();
facilityType.ValidateUK2012(log, true);
string msg;
facilityType.WriteJson(jsonFile, true);
facilityType.WriteCobie("..\\..\\Lakeside_Restaurant.xlsx", out msg, rolefilters, "UK2012", true);
break;
}
}
}
public async Task <int> Count(RoleFilter filter)
{
IQueryable <RoleDAO> Roles = DataContext.Role.AsNoTracking();
Roles = DynamicFilter(Roles, filter);
return(await Roles.CountAsync());
}
private IQueryable <RoleDAO> DynamicFilter(IQueryable <RoleDAO> query, RoleFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <RoleDAO> OrFilter(IQueryable <RoleDAO> query, RoleFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <RoleDAO> initQuery = query.Where(q => false);
foreach (RoleFilter RoleFilter in filter.OrFilter)
{
IQueryable <RoleDAO> queryable = query;
if (RoleFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, RoleFilter.Id);
}
if (RoleFilter.Code != null)
{
queryable = queryable.Where(q => q.Code, RoleFilter.Code);
}
if (RoleFilter.Name != null)
{
queryable = queryable.Where(q => q.Name, RoleFilter.Name);
}
if (RoleFilter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, RoleFilter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public ActionResult GetRoleList(RoleFilter filter)
{
int total = 0;
var data = business.GetRoleList(filter, out total);
return(Json(new TableDataModel(total, data)));
}
[InlineData("asd}asd", -1, -1, RoleSorting.UNDEFINED, Order.UNDEFINED)] // code con caracter inválido
public async Task InvalidFilter__ValidationError(string textSearch, int page, int pageSize, RoleSorting sortBy, Order orderBy)
{
var form = new RoleFilter(page, pageSize, sortBy, orderBy, textSearch);
var actionResult = await _sut.GetByFilter(form);
Assert.NotNull(actionResult);
Assert.IsType <BadRequestObjectResult>(actionResult);
}
public List <RoleModel> GetRoleList(RoleFilter filter, out int total)
{
using (DataProvider dp = new DataProvider())
{
List <RoleModel> list = Mapper.Map <List <RoleModel> >(data.GetRoleList(dp, filter, out total));
return(list);
}
}
public FilterDlg(OutPutFilters assetfilters, bool seeMergeFilterOnRole = false, Dictionary<FileInfo, OutPutFilters> FedFilters = null)
{
InitializeComponent();
SeeMergeFilter = seeMergeFilterOnRole;
Roles = assetfilters.AppliedRoles;
RolesFilters = assetfilters;
SetFilter(FedFilters);
}
public List <Role> GetAllRoles(RoleFilter filter, int pageIndex, int pageSize, out int totalCount)
{
string querySql = "SELECT \"row_number\"() OVER(ORDER BY r.\"CreateTime\" desc) \"rownum\", r.\"Id\",r.\"Name\",r.\"Description\",u.\"UserName\" as \"OperatorName\",r.\"CreateTime\",r.\"Remark\" from \"T_Role\" r join \"T_User\" u on u.\"Id\"=r.\"OperatorId\"";
string countSql = "SELECT COUNT (r.\"Id\") FROM \"T_Role\" r join \"T_User\" u on u.\"Id\"=r.\"OperatorId\"";
return(GetPagedData <Role, RoleFilter>(pageIndex, pageSize, out totalCount, countSql, querySql, filter));
}
public FilterDlg(OutPutFilters assetfilters, bool seeMergeFilterOnRole = false, Dictionary <FileInfo, OutPutFilters> FedFilters = null)
{
InitializeComponent();
SeeMergeFilter = seeMergeFilterOnRole;
Roles = assetfilters.AppliedRoles;
RolesFilters = assetfilters;
SetFilter(FedFilters);
}
public static string ToResourceName(this RoleFilter filter)
{
const string format = "Xbim.CobieExpress.Exchanger.FilterHelper.COBie{0}Filters.config";
return(filter == RoleFilter.Unknown
? string.Format(format, "Default")
: string.Format(format, filter));
}
/// <summary>
/// Add filter for a role, used by ApplyRoleFilters for none default filters
/// </summary>
/// <param name="role">RoleFilter, single flag RoleFilter</param>
/// <param name="filter">OutPutFilters to assign to role</param>
/// <remarks>Does not apply filter to this object, used ApplyRoleFilters after setting the RolesFilterHolder items </remarks>
public void AddRoleFilterHolderItem(RoleFilter role, OutPutFilters filter)
{
if ((role & (role - 1)) != 0)
{
throw new ArgumentException("More than one flag set on role");
}
RolesFilterHolder[role] = filter;
}
public void RolesFilters_Can_Have_Multiple_Values()
{
RoleFilter.Architectural.HasMultipleFlags().Should().BeFalse();
(RoleFilter.Architectural | RoleFilter.Electrical).HasMultipleFlags().Should().BeTrue();
RoleFilter undefined = 0;
undefined.HasMultipleFlags().Should().BeFalse();
}
public OutputFilters(ILogger logger, RoleFilter roleFlags) : this(logger)
{
AppliedRoles = roleFlags;
if (roleFlags.HasMultipleFlags())
{
throw new InvalidOperationException("Cannot construct with multiple roles. Use OutputFilters.Merge to add additional roles");
}
FiltersHelperInit(roleFlags.ToResourceName());
}
/// <summary>
/// Get ActorRoles mapped to roles held in RoleFilter Flags
/// </summary>
/// <param name="role">RoleFilter</param>
/// <returns>List of IfcActorRole</returns>
private List <IIfcActorRole> GetActorRoles(RoleFilter role)
{
if (RoleMap == null)
{
RoleMap = new Dictionary <RoleFilter, IIfcActorRole>();
}
var actorRoles = new List <IIfcActorRole>();
using (var tx = Model.BeginTransaction("RoleSettings"))
{
if (role.HasFlag(RoleFilter.Architectural))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.Architectural)
? RoleMap[RoleFilter.Architectural]
: MapRole(RoleFilter.Architectural, IfcRoleEnum.ARCHITECT));
}
if (role.HasFlag(RoleFilter.Mechanical))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.Mechanical)
? RoleMap[RoleFilter.Mechanical]
: MapRole(RoleFilter.Mechanical, IfcRoleEnum.MECHANICALENGINEER));
}
if (role.HasFlag(RoleFilter.Electrical))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.Electrical)
? RoleMap[RoleFilter.Electrical]
: MapRole(RoleFilter.Electrical, IfcRoleEnum.ELECTRICALENGINEER));
}
if (role.HasFlag(RoleFilter.Plumbing))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.Plumbing)
? RoleMap[RoleFilter.Plumbing]
: MapRole(RoleFilter.Plumbing, IfcRoleEnum.USERDEFINED));
}
if (role.HasFlag(RoleFilter.FireProtection))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.FireProtection)
? RoleMap[RoleFilter.FireProtection]
: MapRole(RoleFilter.FireProtection, IfcRoleEnum.USERDEFINED));
}
if (role.HasFlag(RoleFilter.Unknown))
{
actorRoles.Add(
RoleMap.ContainsKey(RoleFilter.Unknown)
? RoleMap[RoleFilter.Unknown]
: MapRole(RoleFilter.Unknown, IfcRoleEnum.USERDEFINED));
}
tx.Commit();
}
return(actorRoles);
}
public async Task <long> CountRole([FromBody] AppUser_RoleFilterDTO AppUser_RoleFilterDTO)
{
RoleFilter RoleFilter = new RoleFilter();
RoleFilter.Id = AppUser_RoleFilterDTO.Id;
RoleFilter.Code = AppUser_RoleFilterDTO.Code;
RoleFilter.Name = AppUser_RoleFilterDTO.Name;
RoleFilter.StatusId = AppUser_RoleFilterDTO.StatusId;
return(await RoleService.Count(RoleFilter));
}
public IHttpActionResult Query()
{
//SecurityHelper.CurrentPrincipal.RoleId;
RoleFilter request = new RoleFilter();
request.RoleId = SecurityHelper.CurrentPrincipal.RoleId;
var response = _service.GetRoleModule(request).ToList().Distinct();
//var response = _service.GetMenus(roleId);
return(Ok(response));
}
public JsonActionResult <IEnumerable <Role> > Search([FromUri] RoleFilter filter)
{
return(SafeExecute(() =>
{
if (!ModelState.IsValid)
{
return null;
}
return this.RoleService.Query(filter);
}));
}
/// <summary>
/// Add the refrence models
/// </summary>
/// <param name="file">FileInfo for the xbimf file</param>
/// <param name="organizationName">Organisation Name</param>
/// <param name="roles"></param>
/// <param name="displayName"></param>
public void AddRefModel(FileInfo file, string organizationName, RoleFilter roles = RoleFilter.Unknown, string displayName = null)
{
if (!file.Exists)
{
throw new FileNotFoundException("Cannot find reference model file", file.FullName);
}
var actorRoles = GetActorRoles(roles);
var roleString = string.Join(",", actorRoles.Select(r => r.RoleString));
//add model to list of referenced models
_fedModel.AddModelReference(file.FullName, organizationName, roleString);
}
public async void GetListRolesWithOkResult()
{
var mock = new Mock <IRolesListQuery>();
var controller = new RolesController();
var role = new RoleFilter();
var options = new ListOptions();
var result = await controller.GetRoleListAsync(role, options, mock.Object);
var viewResult = Assert.IsType <OkObjectResult>(result);
Assert.Equal(200, viewResult?.StatusCode);
}
public static IQueryable <Role> Filter(this IQueryable <Role> queryable, RoleFilter filter)
{
if (!string.IsNullOrEmpty(filter?.Text))
{
queryable = queryable.Where(e => e.Name.Contains(filter.Text));
}
if (!string.IsNullOrEmpty(filter?.Name))
{
queryable = queryable.Where(e => e.Name.Contains(filter.Name));
}
return(queryable);
}
/// <summary>
/// Get the default filters for a single role
/// </summary>
/// <param name="role">RoleFilter with single flag(role) set</param>
/// <returns>OutPutFilters</returns>
public static OutPutFilters GetDefaults(RoleFilter role)
{
if ((role & (role - 1)) != 0)
{
throw new ArgumentException("More than one flag set on role");
}
var filterFile = role.ToResourceName();
return(!string.IsNullOrEmpty(filterFile)
? new OutPutFilters(filterFile, role)
: null);
}
/// <summary>
/// Extension method to use default role configuration resource files
/// </summary>
/// <param name="roles">MergeRoles, Flag enum with one or more roles</param>
/// <param name="append">true = add, false = overwrite existing </param>
/// <param name="rolesFilter">Dictionary of roles to OutPutFilters to use for merge, overwrites current assigned dictionary</param>
public void ApplyRoleFilters(RoleFilter roles, bool append = false, Dictionary <RoleFilter, OutPutFilters> rolesFilter = null)
{
if (rolesFilter != null)
{
RolesFilterHolder = rolesFilter;
}
bool init = append ? !this.IsEmpty(): false;
OutPutFilters mergeFilter = null;
foreach (RoleFilter role in Enum.GetValues(typeof(RoleFilter)))
{
if (roles.HasFlag(role))
{
if (RolesFilterHolder.ContainsKey(role))
{
mergeFilter = RolesFilterHolder[role];
}
else
{ //load defaults
string mergeFile = GetDefaultRoleFile(role);
if (!string.IsNullOrEmpty(mergeFile))
{
mergeFilter = new OutPutFilters(mergeFile, role);
RolesFilterHolder[role] = mergeFilter;
}
}
if (mergeFilter != null)
{
if (!init)
{
this.Copy(mergeFilter); //start a fresh
init = true; //want to merge on next loop iteration
}
else
{
this.Merge(mergeFilter);
}
}
mergeFilter = null;
}
}
//add the default property filters
OutPutFilters defaultPropFilters = new OutPutFilters(null, RoleFilter.Unknown, ImportSet.PropertyFilters);
this.Merge(defaultPropFilters);
//save the applied roles at end as this.Copy(mergeFilter) would set to first role in RoleFilter
AppliedRoles = roles;
}
public string Execute(
TransitionContext context)
{
string retEvent = EVENT_ERROR;
try
{
// TODO: this should come from DAOFactory!!
// AccountDAO dao = AccountDAOFactory.GetAccountDAO();
// get the filter from the DAO
RoleFilter filter = new RoleFilter();
// populate the filter from the request
//filter.Fill(context.Request);
// get the account for the given username
Dictionary<string, Role> result = RoleManager.GetInstance().GetRoles(filter);
context.Request.Items[RequestItemName] = result;
// determine which event to return based on the number of
// accounts found
switch (result.Count)
{
case 0:
retEvent = EVENT_FOUND_0;
break;
case 1:
retEvent = EVENT_FOUND_1;
break;
default:
retEvent = EVENT_FOUND_MULTIPLE;
break;
}
}
catch (Exception e)
{
Logger.GetLogger(MembershipConstants.ACTION_LOGGER).Error("GetUserAction", e);
}
return retEvent;
}
public List<int> GetRoleIds(RoleFilter filter)
{
/* select Role_Id
* from member_role mro
* //get role based on username
* join member_account_username mau
* on mau.account_id = ??
* join member_account_role mar
* on mau.account_id = mar.account_id and
* mro.role_id = mar.role_id
*/
//reasoning for a global try catch:
//if the function fails at any moment we want to exit and get back to the callee
//SearchResult<Account> searchResult = null;
SqlConnection conn = null;
SqlCommand cmd = null;
SqlDataReader dr = null;
List<int> roleList = new List<int>();
try
{
List<string> fields = new List<string>();
List<string> joinTables = new List<string>();
List<string> where = new List<string>();
conn = (SqlConnection)this.GetConnection();
cmd = new SqlCommand();
fields.AddRange(new string[] { "mr.role_id" });
if (filter.RoleIds.Count > 0)
{
StringBuilder roleids = new StringBuilder();
roleids.Append("mr.role_id in (");
for (int i = 0; i < filter.RoleIds.Count; i++)
{
string roleParamName = "@Role_Id" + i;
roleids.Append(roleParamName + ",");
cmd.Parameters.AddWithValue(roleParamName, filter.RoleIds[i]);
}
//remove the trailing ,
roleids.Length--;
roleids.Append(")");
where.Add(roleids.ToString());
} else {
if (filter.ContextIds.Count > 0)
{
StringBuilder contextids = new StringBuilder();
contextids.Append("mr.context_id in (");
for (int i = 0; i < filter.ContextIds.Count; i++)
{
string contextParamName = "@Context_Id" + i;
contextids.Append(contextParamName + ",");
cmd.Parameters.AddWithValue(contextParamName, filter.ContextIds[i]);
}
//remove the trailing ,
contextids.Length--;
contextids.Append(")");
where.Add(contextids.ToString());
}
if (filter.Code != "")
{
where.Add("mr.role_code like @rolecode");
cmd.Parameters.AddWithValue("@rolecode", "%" + filter.Code + "%");
}
if (filter.Description != "")
{
where.Add("mr.role_description like @roledescription");
cmd.Parameters.AddWithValue("@roledescription", "%" + filter.Description + "%");
}
if (filter.AccountId != Guid.Empty)
{
//get the accounts by status id
joinTables.Add("join member_account_role mar on mr.role_id = mar.role_id");
joinTables.Add("join member_account mac on mar.account_id = mac.account_id");
//joinTables.Add("join member_role mro on mro.role_id = mar.role_id");
// join member_account_role mar on ma.account_id = mar.account_id
// join member_role mr on mr.role_id = mar.role_id
StringBuilder status = new StringBuilder();
status.Append("mac.account_id = @accountId");
cmd.Parameters.AddWithValue("@accountId", filter.AccountId);
where.Add(status.ToString());
}
}
cmd.Connection = conn;
cmd.CommandText = "select " + BuildFields(fields) +
" from member_role mr (nolock) " +
BuildJoins(joinTables) +
BuildWhere(where);
cmd.Connection.Open();
#if (DEBUG)
logger.Status("SQL : " + cmd.CommandText);
#endif
dr = cmd.ExecuteReader();
while (dr.Read())
{
//Role role = new Role(DbUtil.getIntValue(dr, "role_id"), DbUtil.getStringValue(dr, "role_code"), DbUtil.getStringValue(dr, "role_description"),DbUtil.getIntValue(dr,"context_id"));
roleList.Add(DbUtil.getIntValue(dr,"role_id"));
}
}
catch (Exception e)
{
logger.Error("MSAccountDAO:GetRoleIds: ", e);
}
finally
{
DbUtil.close((cmd == null) ? null : cmd.Connection, cmd, dr);
}
//searchResult = new SearchResult<Account>(
// accountList.ToArray(),
// filter,
// accountList.Count,
// accountList.Count,
// 0,
// 0,
// accountList.Count,
// 1,
// accountList.Count,
// 1);
return roleList;
}
/// <summary>
/// Add the refrence models
/// </summary>
/// <param name="file">FileInfo for the xbimf file</param>
/// <param name="organizationName">Organisation Name</param>
/// <param name="role">RoleFilter</param>
/// <param name="displayName"></param>
public void AddRefModel(FileInfo file, string organizationName, RoleFilter roles = RoleFilter.Unknown, string displayName = null)
{
if (!file.Exists)
throw new FileNotFoundException("Cannot find reference model file", file.FullName);
//add model to list of referenced models
IfcIdentifier docId = _fedModel.AddModelReference(file.FullName, organizationName, IfcRole.UserDefined).Identifier;
using (var txn = _fedModel.BeginTransaction())
{
IfcDocumentInformation addDocId = _fedModel.ReferencedModels.Where(item => item.DocumentInformation.DocumentId == docId).Select(item => item.DocumentInformation).FirstOrDefault();
IfcOrganization org = addDocId.DocumentOwner as IfcOrganization;
if (org != null)
{
org.Roles.Clear();
//Add Roles
foreach (var item in GetActorRoles(roles))
{
org.AddRole(item);
}
}
//add display name if required
if (displayName != null)
{
addDocId.Description = displayName;
}
txn.Commit();
}
}
/// <summary>
/// Convert RoleFilter to IfcActorRole, need to be within a transaction
/// </summary>
/// <param name="role">RoleFilter</param>
/// <param name="ifcRole">IfcRole</param>
/// <returns></returns>
private IfcActorRole MapRole(RoleFilter role, IfcRole ifcRole)
{
if (_fedModel.IsTransacting)
{
IfcActorRole actorRole = _fedModel.Instances.New<IfcActorRole>();
if (ifcRole == IfcRole.UserDefined)
{
actorRole.Role = IfcRole.UserDefined;
actorRole.UserDefinedRole = role.ToString();
}
else
{
actorRole.Role = ifcRole;
}
actorRole.Description = role.ToString();
RoleMap.Add(role, actorRole);
return actorRole;
}
else
{
throw new InvalidOperationException("MapRole: No transaction currently in model");
}
}
/// <summary>
/// Get ActorRoles mapped to roles held in RoleFilter Flags
/// </summary>
/// <param name="role">RoleFilter</param>
/// <returns>List of IfcActorRole</returns>
private List<IfcActorRole> GetActorRoles(RoleFilter role)
{
if (RoleMap == null) RoleMap = new Dictionary<RoleFilter, IfcActorRole>();
List<IfcActorRole> actorRoles = new List<IfcActorRole>();
if (role.HasFlag(RoleFilter.Architectural))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Architectural) ? RoleMap[RoleFilter.Architectural] : MapRole(RoleFilter.Architectural, IfcRole.Architect));
}
if (role.HasFlag(RoleFilter.Mechanical))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Mechanical) ? RoleMap[RoleFilter.Mechanical] : MapRole(RoleFilter.Mechanical, IfcRole.MechanicalEngineer));
}
if (role.HasFlag(RoleFilter.Electrical))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Electrical) ? RoleMap[RoleFilter.Electrical] : MapRole(RoleFilter.Electrical, IfcRole.ElectricalEngineer));
}
if (role.HasFlag(RoleFilter.Plumbing))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Plumbing) ? RoleMap[RoleFilter.Plumbing] : MapRole(RoleFilter.Plumbing, IfcRole.UserDefined));
}
if (role.HasFlag(RoleFilter.FireProtection))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.FireProtection) ? RoleMap[RoleFilter.FireProtection] : MapRole(RoleFilter.FireProtection, IfcRole.UserDefined));
}
if (role.HasFlag(RoleFilter.Unknown))
{
actorRoles.Add(RoleMap.ContainsKey(RoleFilter.Unknown) ? RoleMap[RoleFilter.Unknown] : MapRole(RoleFilter.Unknown, IfcRole.UserDefined));
}
return actorRoles;
}
public SearchResult<Role> FindRoles(RoleFilter filter)
{
/* select Role_Id
* from member_role mro
* //get role based on username
* join member_account_username mau
* on mau.account_id = ??
* join member_account_role mar
* on mau.account_id = mar.account_id and
* mro.role_id = mar.role_id
*/
//reasoning for a global try catch:
//if the function fails at any moment we want to exit and get back to the callee
SearchResult<Role> searchResult = null;
SQLiteConnection conn = null;
SQLiteCommand cmd = null;
SQLiteDataReader dr = null;
List<Role> roleList = new List<Role>();
try
{
List<string> fields = new List<string>();
List<string> joinTables = new List<string>();
List<string> where = new List<string>();
conn = (SQLiteConnection)this.GetConnection();
cmd = new SQLiteCommand();
fields.AddRange(new string[] { "mr.role_id, mr.role_code, mr.role_description, mr.context_id" });
//if (filter.Context != "")
//{
// StringBuilder accounts = new StringBuilder();
// accounts.Append("mr.context_id = @contextId");
// cmd.Parameters.AddWithValue("@contextId", SingletonBase<MemberContext>.GetInstance()[filter.Context].Id);
// where.Add(accounts.ToString());
//}
if (filter.RoleIds.Count > 0)
{
StringBuilder roleids = new StringBuilder();
roleids.Append("mr.role_id in (");
for (int i = 0; i < filter.RoleIds.Count; i++)
{
string roleParamName = "@Role_Id" + i;
roleids.Append(roleParamName + ",");
cmd.Parameters.AddWithValue(roleParamName, filter.RoleIds[i]);
}
//remove the trailing ,
roleids.Length--;
roleids.Append(")");
where.Add(roleids.ToString());
}
if (filter.ContextIds.Count > 0)
{
//get the accounts by username
//joinTables.Add("join member_account_username mau on mac.account_id = mau.account_id");
StringBuilder contextids = new StringBuilder();
contextids.Append("mr.context_id in (");
for (int i = 0; i < filter.ContextIds.Count; i++)
{
string contextParamName = "@Context_Id" + i;
contextids.Append(contextParamName + ",");
cmd.Parameters.AddWithValue(contextParamName, filter.ContextIds[i]);
}
//remove the trailing ,
contextids.Length--;
contextids.Append(")");
where.Add(contextids.ToString());
}
if (filter.AccountId != Guid.Empty)
{
//get the accounts by status id
joinTables.Add("join member_account_role mar on mr.role_id = mar.role_id");
joinTables.Add("join member_account mac on mar.account_id = mac.account_id");
//joinTables.Add("join member_role mro on mro.role_id = mar.role_id");
StringBuilder status = new StringBuilder();
status.Append("mac.account_id = @accountId");
cmd.Parameters.AddWithValue("@accountId", filter.AccountId.ToString());
where.Add(status.ToString());
}
if (filter.Code != "")
{
where.Add("mr.role_code like @rolecode");
cmd.Parameters.AddWithValue("@rolecode", "%" + filter.Code + "%");
}
if (filter.Description != "")
{
where.Add("mr.role_description like @roledescription");
cmd.Parameters.AddWithValue("@roledescription", "%" + filter.Description + "%");
}
cmd.Connection = conn;
cmd.CommandText = "select " + BuildFields(fields) +
" from member_role mr " +
BuildJoins(joinTables) +
BuildWhere(where);
cmd.Connection.Open();
dr = cmd.ExecuteReader();
while (dr.Read())
{
Role role = new Role(DbUtil.getIntValue(dr, "role_id"), DbUtil.getStringValue(dr, "role_code"), DbUtil.getStringValue(dr, "role_description"),DbUtil.getIntValue(dr,"context_id"));
roleList.Add(role);
}
}
catch (Exception e)
{
logger.Error("SQLiteAccountDAO::GetRoleIds: ", e);
}
finally
{
DbUtil.close((cmd == null) ? null : cmd.Connection, cmd, dr);
}
searchResult = new SearchResult<Role>(
roleList,
filter,
roleList.Count,
roleList.Count,
0,
0,
roleList.Count,
1,
roleList.Count,
1);
return searchResult;
}
