public ICurrentUserContextModel GetCurrentUserContext()
{
var managementDepartments = new List <IManagementDepartmentModel>();
IMemberModel currentUser = GetCurrentUser();
if (currentUser.CurrentRole == RoleType.Coordinator)
{
IEnumerable <Guid> ids = currentUser.ManagementsToActiveRolesRelation[currentUser.CurrentRole];
managementDepartments = managementDepartmentService.GetManagementDepartmentsByIds(ids).ToList();
}
else
{
Member member = memberRepository.Query.First(x => x.Id == currentUser.MemberId);
IEnumerable <string> managementDepartmentSyncIds = member.RoleList
.Where(x => !x.IsDeleted && x.RoleId == (int)currentUser.CurrentRole)
.Select(x => x.ManagementDepartmentId);
managementDepartments = managementDepartmentService.GetManagementDepartmentsBySyncIds(managementDepartmentSyncIds).ToList();
}
return(new CurrentUserContextModel
{
MemberModel = currentUser,
ManagementDepartments = managementDepartments,
SelectedManagementDepartment = GetSelectedManagementDepartment(currentUser.ActiveManagementDepartmentId, managementDepartments)
});
}
public async Task <HttpResponseMessage> UploadFileWhenChangeJobStatus()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType));
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var contents = provider.Contents;
var fileContent = contents.FirstOrDefault(x => x.Headers.ContentDisposition.FileName.IsNotNullOrEmpty());
if (fileContent == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
var fileId = Guid.NewGuid();
var buffer = await fileContent.ReadAsByteArrayAsync();
var originalName = fileContent.Headers.ContentDisposition.FileName.Trim('"');
var absolutePathPart = HostingEnvironment.MapPath(Constants.Upload.DayAssignUploadPath);
var dayAssignId = (await GetParameter(contents, "dayAssignId")).ToGuid();
IMemberModel currentUser = memberService.GetCurrentUser();
await messageBus.Publish(new DayAssignUploadFileCommand(fileId, buffer, originalName, absolutePathPart, dayAssignId, currentUser.MemberId));
return(Request.CreateResponse(HttpStatusCode.OK, new { fileId }));
}
public void UpdateMember(int daysAhead, Guid?departmentId)
{
IMemberModel currentUser = GetCurrentUser();
if (currentUser == null)
{
return;
}
Member member = memberRepository.Query.First(m => m.Id == currentUser.MemberId);
UnsetOldActiveRole(member, currentUser.CurrentRole);
if (departmentId.HasValue)
{
IManagementDepartmentModel managementDepartmentModel = managementDepartmentService.GetManagementDepartmentById(departmentId.Value);
Role role = member.RoleList.First(x => x.RoleId == (int)currentUser.CurrentRole && x.ManagementDepartmentId == managementDepartmentModel.SyncDepartmentId);
role.IsActive = true;
}
else
{
Role role = member.RoleList.First(x => x.RoleId == (int)member.CurrentRole);
role.IsActive = true;
}
member.DaysAhead = daysAhead;
memberRepository.Save(member);
}
public IMemberModel GetByEmail(string email)
{
Member user = memberRepository.Query.FirstOrDefault(i => i.Email == email.ToLowerInvariant());
IMemberModel result = MapMember(user, mapCoordinatorProperties: true);
return(result);
}
public IMemberModel GetByUserName(string userName)
{
Member user = memberRepository.Query.FirstOrDefault(i => i.UserName == userName);
IMemberModel result = MapMember(user, mapCoordinatorProperties: true);
return(result);
}
private static Expression CustomResolverFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var config = arg.Settings;
var resolvers = config.Resolvers;
if (resolvers == null || resolvers.Count <= 0)
return null;
Expression getter = null;
LambdaExpression lastCondition = null;
for (int j = 0; j < resolvers.Count; j++)
{
var resolver = resolvers[j];
if (destinationMember.Name.Equals(resolver.MemberName))
{
Expression invoke = resolver.Invoker.Apply(source);
getter = lastCondition != null
? Expression.Condition(lastCondition.Apply(source), getter, invoke)
: invoke;
lastCondition = resolver.Condition;
if (resolver.Condition == null)
break;
}
}
if (lastCondition != null)
getter = Expression.Condition(lastCondition.Apply(source), getter, Expression.Constant(getter.Type.GetDefault(), getter.Type));
return getter;
}
public async Task <FormattedJobAssignViewModel> GetJobAssigns(string jobId, UploadedContentEnum?contentType)
{
IMemberModel currentUser = memberService.GetCurrentUser();
IJob job = await jobService.GetJobById(jobId);
var result = new FormattedJobAssignViewModel();
if (job.RelationGroupList.Any() && job.ParentId != null)
{
Guid housingDepartmentId = job.RelationGroupList.First().HousingDepartmentId;
IEnumerable <Guid> relationGroupIdList = job.RelationGroupList.Select(x => x.RelationGroupId).ToList();
JobAssign globalGroupedJobAssign = jobService.GetGlobalJobAssignForGroupedTask(job);
List <JobAssign> jobAssigns = jobService.GetJobAssignList(relationGroupIdList);
result.GlobalAssign = globalGroupedJobAssign.Map <JobAssignViewModel>();
result.Assigns = jobAssigns.Where(i => !i.IsGlobal && i.HousingDepartmentIdList.Contains(housingDepartmentId)).Select(i => i.Map <JobAssignViewModel>()).ToList();
result.AddressList = jobService.GetRelatedAddressListForHousingDepartment(relationGroupIdList, housingDepartmentId, isParent: false);
result.IsGroupedJob = true;
result.IsChildJob = job.ParentId != null;
}
else
{
IFormattedJobAssign jobAssign = jobService.GetAllByJobIdFormatted(jobId, currentUser.IsAdmin() ? null : currentUser.ActiveManagementDepartmentId);
result = Mapper.Map <FormattedJobAssignViewModel>(jobAssign);
}
result.CurrentUser = currentUser;
result.GlobalAssign.UploadList = GetUploadListModel(result.GlobalAssign.UploadList, contentType);
foreach (var assign in result.Assigns)
{
assign.UploadList = GetUploadListModel(assign.UploadList, contentType);
}
return(result);
}
private static Expression FlattenMemberFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = strategy.DestinationMemberNameConverter(destinationMember.Name);
return(ReflectionUtils.GetDeepFlattening(source, destinationMemberName, arg));
}
private static Expression?FlattenMemberFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = destinationMember.GetMemberName(MemberSide.Destination, arg.Settings.GetMemberNames, strategy.DestinationMemberNameConverter);
return(GetDeepFlattening(source, destinationMemberName, arg));
}
private static IEnumerable <string> GetDeepUnflattening(IMemberModel destinationMember, string propertyName, CompileArgument arg)
{
var strategy = arg.Settings.NameMatchingStrategy;
var members = destinationMember.Type.GetFieldsAndProperties(true);
foreach (var member in members)
{
if (!member.ShouldMapMember(arg, MemberSide.Destination))
{
continue;
}
var destMemberName = member.GetMemberName(MemberSide.Destination, arg.Settings.GetMemberNames, strategy.DestinationMemberNameConverter);
var propertyType = member.Type;
if (string.Equals(propertyName, destMemberName))
{
yield return(member.Name);
}
else if (propertyName.StartsWith(destMemberName) &&
(propertyType.IsPoco() || propertyType.IsRecordType()))
{
foreach (var prop in GetDeepUnflattening(member, propertyName.Substring(destMemberName.Length).TrimStart('_'), arg))
{
yield return(member.Name + "." + prop);
}
}
}
}
public IChangeStatusInfo GetJobStatusInfo(IJobStatusLogModel jobStatusLog, IDayAssign dayAssign)
{
ChangeStatusInfo resultModel = null;
if (IsValidLog(jobStatusLog, dayAssign))
{
resultModel = new ChangeStatusInfo
{
ChangeStatusComment = jobStatusLog.Comment,
CancellationReason = jobStatusLog.CancelingReason,
ChangeStatusDate = jobStatusLog.Date,
UploadedFileList = GetUploadedFileList(dayAssign)
};
IMemberModel member = memberService.GetById(jobStatusLog.MemberId);
if (member != null)
{
resultModel.Avatar = member.Avatar;
resultModel.Name = member.Name;
}
}
return(resultModel);
}
public IMemberModel GetCurrentUser()
{
string userName = authenticationService.GetCurrentUserName();
IMemberModel result = GetByUserName(userName);
return(result);
}
private static bool ProcessIgnores(TypeAdapterSettings config, IMemberModel destinationMember)
{
if (config.IgnoreMembers.Contains(destinationMember.Name))
return true;
var attributes = destinationMember.GetCustomAttributes(true).Select(attr => attr.GetType());
return config.IgnoreAttributes.Overlaps(attributes);
}
private static Expression DictionaryFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var dictType = source.Type.GetDictionaryType();
if (dictType == null)
{
return(null);
}
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = destinationMember.GetMemberName(arg.Settings.GetMemberNames, strategy.DestinationMemberNameConverter);
var key = Expression.Constant(destinationMemberName);
var args = dictType.GetGenericArguments();
if (strategy.SourceMemberNameConverter != NameMatchingStrategy.Identity)
{
var method = typeof(CoreExtensions).GetMethods().First(m => m.Name == nameof(CoreExtensions.FlexibleGet)).MakeGenericMethod(args[1]);
return(Expression.Call(method, source.To(dictType), key, Expression.Constant(strategy.SourceMemberNameConverter)));
}
else
{
var method = typeof(CoreExtensions).GetMethods().First(m => m.Name == nameof(CoreExtensions.GetValueOrDefault)).MakeGenericMethod(args);
return(Expression.Call(method, source.To(dictType), key));
}
}
public IMemberModel GetById(Guid id, bool mapCoordinatorProperties = false)
{
Member user = memberRepository.Query.FirstOrDefault(i => i.Id == id);
IMemberModel result = MapMember(user, mapCoordinatorProperties);
return(result);
}
public Form2(List <ICheckoutModel> checkoutHistory, IMemberModel member, IDataConnection dataConnection)
{
//_dataConnection = dataConnection;
//_checkoutHistory = checkoutHistory;
//_member = member;
//InitializeComponent();
}
private List <Job> GetJobs(IEnumerable <Guid> categoryIds, IMemberModel user)
{
List <Job> jobs = user.IsAdmin()
? jobProvider.Get(categoryIds)
: jobProvider.GetByCategoryIdsForCoordinator(categoryIds, user);
return(jobs);
}
public static string GetMemberName(this IMemberModel member, MemberSide side, List <Func <IMemberModel, MemberSide, string?> > getMemberNames, Func <string, string> nameConverter)
{
var memberName = getMemberNames.Select(func => func(member, side))
.FirstOrDefault(name => name != null)
?? member.Name;
return(nameConverter(memberName));
}
public static string GetMemberName(this IMemberModel member, List <Func <IMemberModel, string?> > getMemberNames, Func <string, string> nameConverter)
{
var memberName = getMemberNames.Select(predicate => predicate(member))
.FirstOrDefault(name => name != null)
?? member.Name;
return(nameConverter(memberName));
}
private IEnumerable <Guid> GetEmployeeIdListForCurrentUser()
{
IMemberModel currentUser = memberService.GetCurrentUser();
return(currentUser.IsAdmin()
? memberService.GetAll().Select(x => x.MemberId)
: memberService.GetEmployeesByManagementDepartment(currentUser.ActiveManagementDepartmentId.Value).Select(x => x.MemberId));
}
private static Expression PropertyOrFieldFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var members = source.Type.GetPublicFieldsAndProperties();
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = strategy.DestinationMemberNameConverter(destinationMember.Name);
return members.Where(member => strategy.SourceMemberNameConverter(member.Name) == destinationMemberName)
.Select(member => member.GetExpression(source))
.FirstOrDefault();
}
private void searchMemberBtn_Click(object sender, EventArgs e)
{
member = GlobalConfig.CreateMemberModel();
member.MemberID = Convert.ToInt32(searchMemberTxt.Text);
MemberID = member.MemberID;
GetMember(MemberID);
WireupSelectedMemberDetail();
WireupCurrentCheckoutCB(member.MemberID);
}
private IEnumerable <IMemberModel> GetMembers(IMemberModel member)
{
if (member.IsAdmin())
{
return(memberService.GetAll());
}
return(memberService.GetAllowedMembersForJobByDepartmentId(member.ActiveManagementDepartmentId.Value));
}
private IEnumerable <IGroupModel> GetGroups(IMemberModel member)
{
if (member.IsAdmin())
{
return(groupService.GetAll());
}
return(groupService.GetByManagementId(member.ActiveManagementDepartmentId.Value));
}
public MemberTreeNode(IMemberModel model)
{
if (model == null)
throw new ArgumentNullException("model");
this.model = model;
// disable lazy loading to avoid showing a useless + sign in the tree.
// remove this line if you add child nodes
LazyLoading = false;
}
private static Expression PropertyOrFieldFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var members = source.Type.GetPublicFieldsAndProperties();
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = strategy.DestinationMemberNameConverter(destinationMember.Name);
return(members.Where(member => strategy.SourceMemberNameConverter(member.Name) == destinationMemberName)
.Select(member => member.GetExpression(source))
.FirstOrDefault());
}
private static Expression GetMethodFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
if (arg.MapType == MapType.Projection)
return null;
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = "Get" + strategy.DestinationMemberNameConverter(destinationMember.Name);
var getMethod = source.Type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
.FirstOrDefault(m => strategy.SourceMemberNameConverter(m.Name) == destinationMemberName);
return getMethod != null ? Expression.Call(source, getMethod) : null;
}
private MemberViewModel GetUploaderModel(Guid uploaderId)
{
IMemberModel member = memberService.GetById(uploaderId);
return(new MemberViewModel
{
Avatar = member.Avatar,
Name = member.Name
});
}
private static bool ProcessIgnores(TypeAdapterSettings config, IMemberModel destinationMember)
{
if (config.IgnoreMembers.Contains(destinationMember.Name))
{
return(true);
}
var attributes = destinationMember.GetCustomAttributes(true).Select(attr => attr.GetType());
return(config.IgnoreAttributes.Overlaps(attributes));
}
public IEnumerable <IMemberModel> GetMembers()
{
IMemberModel currentUser = memberService.GetCurrentUser();
if (currentUser.ActiveManagementDepartmentId.HasValue)
{
return(memberService.GetEmployeesByManagementDepartment(currentUser.ActiveManagementDepartmentId.Value));
}
return(memberService.GetEmployees());
}
private static Expression?CustomResolverFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var config = arg.Settings;
var resolvers = config.Resolvers;
if (resolvers == null || resolvers.Count <= 0)
{
return(null);
}
var invokes = new List <Tuple <Expression, Expression> >();
Expression?getter = null;
foreach (var resolver in resolvers)
{
if (!destinationMember.Name.Equals(resolver.DestinationMemberName))
{
continue;
}
var invoke = resolver.Invoker == null
? ExpressionEx.PropertyOrField(source, resolver.SourceMemberName)
: resolver.IsChildPath
? resolver.Invoker.Body
: resolver.Invoker.Apply(arg.MapType, source);
if (resolver.Condition == null)
{
getter = invoke;
break;
}
var condition = resolver.IsChildPath
? resolver.Condition.Body
: resolver.Condition.Apply(arg.MapType, source);
invokes.Add(Tuple.Create(condition, invoke));
}
if (invokes.Count > 0)
{
invokes.Reverse();
if (getter == null)
{
var type = invokes[0].Item2.Type;
getter = type.CreateDefault();
}
foreach (var invoke in invokes)
{
getter = Expression.Condition(invoke.Item1, invoke.Item2, getter);
}
}
return(getter);
}
public IEnumerable <IMemberModel> GetAllowedMembersForJob()
{
IMemberModel currentUser = memberService.GetCurrentUser();
if (currentUser.ActiveManagementDepartmentId.HasValue)
{
return(memberService.GetAllowedMembersForJobByDepartmentId(currentUser.ActiveManagementDepartmentId.Value));
}
return(memberService.GetAllowedMembersForJob());
}
private static Expression?PropertyOrFieldFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var members = source.Type.GetFieldsAndProperties(accessorFlags: BindingFlags.NonPublic | BindingFlags.Public);
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = destinationMember.GetMemberName(arg.Settings.GetMemberNames, strategy.DestinationMemberNameConverter);
return(members
.Where(member => member.ShouldMapMember(arg, MemberSide.Source))
.Where(member => member.GetMemberName(arg.Settings.GetMemberNames, strategy.SourceMemberNameConverter) == destinationMemberName)
.Select(member => member.GetExpression(source))
.FirstOrDefault());
}
private static bool ProcessCustomResolvers(
Expression source,
Expression destination,
TypeAdapterSettings config,
IMemberModel destinationMember,
List <MemberConverter> properties)
{
bool isAdded = false;
var resolvers = config.Resolvers;
if (resolvers != null && resolvers.Count > 0)
{
MemberConverter memberConverter = null;
LambdaExpression lastCondition = null;
for (int j = 0; j < resolvers.Count; j++)
{
var resolver = resolvers[j];
if (destinationMember.Name.Equals(resolver.MemberName))
{
if (memberConverter == null)
{
memberConverter = new MemberConverter
{
ConvertType = 5,
Setter = destinationMember.GetExpression(destination),
SetterInfo = destinationMember.Info,
};
isAdded = true;
}
Expression invoke = resolver.Invoker.Apply(source);
memberConverter.Getter = lastCondition != null
? Expression.Condition(lastCondition.Apply(source), memberConverter.Getter, invoke)
: invoke;
lastCondition = resolver.Condition;
if (resolver.Condition == null)
{
break;
}
}
}
if (memberConverter != null)
{
if (lastCondition != null)
{
memberConverter.Getter = Expression.Condition(lastCondition.Apply(source), memberConverter.Getter, Expression.Constant(memberConverter.Getter.Type.GetDefault(), memberConverter.Getter.Type));
}
properties.Add(memberConverter);
}
}
return(isAdded);
}
public IEnumerable <HousingDepartmentViewModel> GetHousingDepartments()
{
IMemberModel currentMember = memberService.GetCurrentUser();
IEnumerable <IHousingDepartmentModel> housingDepartments = currentMember.IsAdmin()
? managementDepartmentService.GetAllHousingDepartments()
: managementDepartmentService.GetHousingDepartments(currentMember.ActiveManagementDepartmentId.Value);
var housingDepartmentsView = housingDepartments.Map <IEnumerable <HousingDepartmentViewModel> >();
return(housingDepartmentsView.OrderBy(x => x.Name));
}
public static CodeElement CreateMember(CodeModelContext context, IMemberModel m)
{
switch (m.SymbolKind) {
case SymbolKind.Field:
return new CodeVariable(context, (IFieldModel)m);
case SymbolKind.Property:
case SymbolKind.Indexer:
// return new CodeProperty2(m);
throw new NotImplementedException();
case SymbolKind.Event:
return null; // events are not supported in EnvDTE?
case SymbolKind.Method:
case SymbolKind.Operator:
case SymbolKind.Constructor:
case SymbolKind.Destructor:
return new CodeFunction2(context, (IMethodModel)m);
default:
throw new NotSupportedException("Invalid value for SymbolKind");
}
}
private static Expression DictionaryFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var dictType = source.Type.GetDictionaryType();
if (dictType == null)
return null;
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = strategy.DestinationMemberNameConverter(destinationMember.Name);
var key = Expression.Constant(destinationMemberName);
var args = dictType.GetGenericArguments();
if (strategy.SourceMemberNameConverter != NameMatchingStrategy.Identity)
{
var method = typeof (Extensions).GetMethods().First(m => m.Name == "FlexibleGet").MakeGenericMethod(args[1]);
return Expression.Call(method, source.To(dictType), key, Expression.Constant(strategy.SourceMemberNameConverter));
}
else
{
var method = typeof(Extensions).GetMethods().First(m => m.Name == "GetValueOrDefault").MakeGenericMethod(args);
return Expression.Call(method, source.To(dictType), key);
}
}
private static Expression FlattenMemberFn(Expression source, IMemberModel destinationMember, CompileArgument arg)
{
var strategy = arg.Settings.NameMatchingStrategy;
var destinationMemberName = strategy.DestinationMemberNameConverter(destinationMember.Name);
return ReflectionUtils.GetDeepFlattening(source, destinationMemberName, arg);
}
