1359 lines
53 KiB
C#
1359 lines
53 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Web.Mvc;
|
|
using EnVisage.Code.BLL;
|
|
using EnVisage.Models;
|
|
using EnVisage.Models.Entities;
|
|
using Microsoft.AspNet.Identity;
|
|
using Microsoft.AspNet.Identity.EntityFramework;
|
|
using EnVisage.Code.Cache;
|
|
|
|
namespace EnVisage.Code
|
|
{
|
|
public static class Utils
|
|
{
|
|
public static T TrimStringProperties<T>(this T obj)
|
|
{
|
|
// ReSharper disable CompareNonConstrainedGenericWithNull
|
|
|
|
if (obj == null)
|
|
throw new ArgumentNullException();
|
|
foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(obj))
|
|
{
|
|
if (prop.PropertyType != typeof (string) || prop.IsReadOnly)
|
|
continue;
|
|
|
|
var val = prop.GetValue(obj) as string;
|
|
if (val != null)
|
|
prop.SetValue(obj, val.Trim());
|
|
}
|
|
|
|
return obj;
|
|
|
|
// ReSharper restore CompareNonConstrainedGenericWithNull
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetFiscalCalendarTypes()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = "",
|
|
Value = ""
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.FiscalCalendarType.CalendarYear.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.FiscalCalendarType.CalendarYear.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.FiscalCalendarType.Calendar445.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.FiscalCalendarType.Calendar445.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.FiscalCalendarType.Calendar454.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.FiscalCalendarType.Calendar454.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.FiscalCalendarType.Calendar544.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.FiscalCalendarType.Calendar544.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetWeekDays()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Monday.ToDisplayValue(),
|
|
Value = DayOfWeek.Monday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Tuesday.ToDisplayValue(),
|
|
Value = DayOfWeek.Tuesday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Wednesday.ToDisplayValue(),
|
|
Value = DayOfWeek.Wednesday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Thursday.ToDisplayValue(),
|
|
Value = DayOfWeek.Thursday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Friday.ToDisplayValue(),
|
|
Value = DayOfWeek.Friday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Saturday.ToDisplayValue(),
|
|
Value = DayOfWeek.Saturday.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = DayOfWeek.Sunday.ToDisplayValue(),
|
|
Value = DayOfWeek.Sunday.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetWeekEndingTypes()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = "",
|
|
Value = ""
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.CalendarYearType.StandardYear.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.CalendarYearType.StandardYear.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.CalendarYearType.Only52Weeks.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.CalendarYearType.Only52Weeks.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = FiscalCalendarModel.CalendarYearType.LastWeekDay.ToDisplayValue(),
|
|
Value = FiscalCalendarModel.CalendarYearType.LastWeekDay.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetOccurrenceTypes()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.SameDayEveryYear.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.SameDayEveryYear.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.FirstDayOfWeek.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.FirstDayOfWeek.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.SecondDayOfWeek.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.SecondDayOfWeek.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.ThirdDayOfWeek.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.ThirdDayOfWeek.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.FourthDayOfWeek.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.FourthDayOfWeek.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.LastDayOfWeek.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.LastDayOfWeek.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.VariesEveryYear.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.VariesEveryYear.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = HolidayModel.HolidayOccurrence.OnlyOnce.ToDisplayValue(),
|
|
Value = HolidayModel.HolidayOccurrence.OnlyOnce.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetMonths()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
var month = new DateTime(2000, 1, 1);
|
|
for (var i = 0; i < 12; i++)
|
|
{
|
|
var nextMonth = month.AddMonths(i);
|
|
options.Add(new SelectListItem
|
|
{
|
|
Value = nextMonth.Month.ToString(CultureInfo.InvariantCulture),
|
|
Text = nextMonth.ToString("MMMM")
|
|
});
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetMonthDays(int month)
|
|
{
|
|
var date = new DateTime(2000, month, 1);
|
|
var options = new List<SelectListItem>();
|
|
while (date.Month == month)
|
|
{
|
|
options.Add(new SelectListItem
|
|
{
|
|
Value = date.Day.ToString(CultureInfo.InvariantCulture),
|
|
Text = date.Day.ToString(CultureInfo.InvariantCulture)
|
|
});
|
|
date = date.AddDays(1);
|
|
|
|
// do not display 29 of February
|
|
if (date.Month == 2 && date.Day == 29)
|
|
break;
|
|
}
|
|
return options;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepares a detailed info about provided object including all property values of target and all inner objects.
|
|
/// </summary>
|
|
/// <param name="obj">An object whose property values will be gathered into <see cref="StringBuilder"/> object <paramref name="sb"/>.</param>
|
|
/// <param name="sb">A <see cref="StringBuilder"/> object that will contain gathered info.</param>
|
|
/// <param name="tab">Initial padding of the object level. "" for the target object, " " for the 1st level inner object, etc..</param>
|
|
public static void DebugObjectProperties(this object obj, StringBuilder sb, string tab = " ")
|
|
{
|
|
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(obj))
|
|
{
|
|
if (property.Attributes.OfType<SkipLoggingAttribute>().Any())
|
|
continue;
|
|
|
|
var value = property.GetValue(obj);
|
|
sb.AppendLine(string.Format("{0}{1}: {2}", tab, property.DisplayName, value));
|
|
if (property.PropertyType != typeof(int) && property.PropertyType != typeof(string) && property.PropertyType != typeof(decimal) &&
|
|
property.PropertyType != typeof(float) && property.PropertyType != typeof(DateTime) && property.PropertyType != typeof(int?) &&
|
|
property.PropertyType != typeof(decimal?) && property.PropertyType != typeof(DateTime?) &&
|
|
TypeDescriptor.GetProperties(value).Count > 0)
|
|
DebugObjectProperties(value, sb, tab + " ");
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetParentCompanies()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var parentCompanies = dbContext.Companies.AsNoTracking().Where(t => t.ParentCompanyId == null);
|
|
options.AddRange(parentCompanies.Select(parentCompany => new SelectListItem()
|
|
{
|
|
Value = parentCompany.Id.ToString(), Text = parentCompany.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetStatuses(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var statuses = dbContext.Status.AsNoTracking().Where(t => !t.IsSystem).OrderBy(s => s.Name);
|
|
options.AddRange(statuses.Select(s => new SelectListItem()
|
|
{
|
|
Value = s.Id.ToString(),
|
|
Text = s.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTypes()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var types = dbContext.Types.AsNoTracking().Where(t => !t.IsSystem).OrderBy(t => t.Name);
|
|
options.AddRange(types.Select(t => new SelectListItem()
|
|
{
|
|
Value = t.Id.ToString(),
|
|
Text = t.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static List<KeyValuePair<string, List<SelectListItem>>> GetTypesWithGroups()
|
|
{
|
|
SortedDictionary<string, List<SelectListItem>> typeDict = new SortedDictionary<string, List<SelectListItem>>();
|
|
typeDict.Add("No Group", new List<SelectListItem>());
|
|
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var types = dbContext.Types.AsNoTracking().Where(t => !t.IsSystem).OrderBy(t => t.Name);
|
|
foreach (EnVisage.Type t in types)
|
|
{
|
|
if (t.Type2TypeGroup.Count == 0)
|
|
{
|
|
typeDict["No Group"].Add(new SelectListItem()
|
|
{
|
|
Value = t.Id.ToString(),
|
|
Text = t.Name
|
|
});
|
|
}
|
|
|
|
foreach (Type2TypeGroup t2g in t.Type2TypeGroup)
|
|
{
|
|
if (!typeDict.ContainsKey(t2g.TypeGroup.Name))
|
|
typeDict.Add(t2g.TypeGroup.Name, new List<SelectListItem>());
|
|
|
|
typeDict[t2g.TypeGroup.Name].Add(new SelectListItem()
|
|
{
|
|
Value = t.Id.ToString(),
|
|
Text = t.Name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return typeDict.ToList();
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTemplates()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
options.Add(new SelectListItem() { Value = "", Text = "" });
|
|
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var types = dbContext.Scenarios.AsNoTracking().Where(t =>
|
|
t.Type == (int)ScenarioType.Template);
|
|
options.AddRange(types.Select(t => new SelectListItem()
|
|
{
|
|
Value = t.Id.ToString(),
|
|
Text = t.Name
|
|
}));
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetClients(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var clients = dbContext.Clients.AsNoTracking().OrderBy(c => c.Name);
|
|
options.AddRange(clients.Select(c => new SelectListItem()
|
|
{
|
|
Value = c.Id.ToString(),
|
|
Text = c.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetCompanies(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var companies = dbContext.Companies.AsNoTracking().OrderBy(c => c.Name);
|
|
options.AddRange(companies.Select(c => new SelectListItem()
|
|
{
|
|
Value = c.Id.ToString(),
|
|
Text = c.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectTemplates(Guid clientId, Guid companyId)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var companies = dbContext.Companies.AsNoTracking().OrderBy(c => c.Name);
|
|
options.AddRange(companies.Select(c => new SelectListItem()
|
|
{
|
|
Value = c.Id.ToString(),
|
|
Text = c.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectParts(Guid? projectId)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
if (projectId.HasValue && !Guid.Empty.Equals(projectId.Value))
|
|
{
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var parts = dbContext.Projects.AsNoTracking().Where(p => p.ParentProjectId == projectId).OrderBy(c => c.Name);
|
|
options.AddRange(parts.Select(c => new SelectListItem()
|
|
{
|
|
Value = c.Id.ToString(),
|
|
Text = c.Name
|
|
}));
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
|
|
#region Date calculation
|
|
/// <summary>
|
|
/// Gets next date with provided DayOfWeek.
|
|
/// </summary>
|
|
/// <param name="startDate">A date to start from.</param>
|
|
/// <param name="weekDay">A day of the week, Monday=1, Tuesday=2, etc.</param>
|
|
/// <param name="counter">Which one of next week days to return, 1st, 2nd, 3rd, etc.</param>
|
|
/// <param name="skipMonthCheck">Indicates whether to let next week day to be on next month or not.</param>
|
|
/// <returns>A <see cref="DateTime"/>.</returns>
|
|
public static DateTime GetNextDateByWeekDate(DateTime startDate, short weekDay, int counter, bool skipMonthCheck = false)
|
|
{
|
|
var date = startDate;
|
|
while (date.DayOfWeek != (DayOfWeek)weekDay && (skipMonthCheck || date.Month == date.AddDays(1).Month))
|
|
{
|
|
date = date.AddDays(1);
|
|
}
|
|
if (counter == 1)
|
|
return date;
|
|
date = date.AddDays(7 * (counter - 1));
|
|
return date;
|
|
}
|
|
public static DateTime GetLastDateByWeekDate(DateTime startDate, short weekDay)
|
|
{
|
|
var date = startDate;
|
|
// find first upcoming weekDay
|
|
while (date.DayOfWeek != (DayOfWeek)weekDay && date.Month == date.AddDays(1).Month)
|
|
{
|
|
date = date.AddDays(1);
|
|
}
|
|
|
|
while (date.Month == date.AddDays(7).Month)
|
|
{
|
|
date = date.AddDays(7);
|
|
}
|
|
return date;
|
|
}
|
|
#endregion
|
|
|
|
public static IEnumerable<SelectListItem> GetSystemAttributeOne()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
options.Add(new SelectListItem()
|
|
{
|
|
Value = Guid.Empty.ToString(),
|
|
Text = "None"
|
|
});
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 1);
|
|
options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
|
|
{
|
|
Value = systemAttribute.Id.ToString(),
|
|
Text = systemAttribute.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetSystemAttributeTwo()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
options.Add(new SelectListItem()
|
|
{
|
|
Value = Guid.Empty.ToString(),
|
|
Text = "None"
|
|
});
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 2);
|
|
options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
|
|
{
|
|
Value = systemAttribute.Id.ToString(),
|
|
Text = systemAttribute.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetExpenditures()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var expenditures = dbContext.Expenditures.AsNoTracking().OrderBy(e => e.Name);
|
|
options.AddRange(expenditures.Select(expenditure => new SelectListItem()
|
|
{
|
|
Value = expenditure.Id.ToString(),
|
|
Text = expenditure.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetExpenditureCategories(Guid parentExpenditureCategory)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var expenditures = dbContext.Expenditures.AsNoTracking().Where(x => !x.ExpenditureCategory.Any(ec => ec.Id == parentExpenditureCategory));
|
|
options.AddRange(expenditures.Select(expenditure => new SelectListItem()
|
|
{
|
|
Value = expenditure.ExpenditureCategory.FirstOrDefault().Id.ToString(),
|
|
Text = expenditure.Name
|
|
}));
|
|
}
|
|
return options.OrderBy(x => x.Text);
|
|
}
|
|
|
|
public static List<ScenarioModel.ExpenditureItem> GetScenarioExpenditures(Guid scenarioId)
|
|
{
|
|
List<ScenarioModel.ExpenditureItem> result;
|
|
using (var context = new EnVisageEntities())
|
|
{
|
|
result = (from c in context.ScenarioDetail.AsNoTracking()
|
|
join o in context.ExpenditureCategory on c.ExpenditureCategoryId equals o.Id
|
|
where c.ParentID == scenarioId
|
|
select new ScenarioModel.ExpenditureItem
|
|
{
|
|
Id = o.Id,
|
|
Name = o.Expenditure.Name
|
|
}).Distinct().ToList();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static IList<SelectListItem> GetResourceExpendituresList(Guid? resourceExpId)
|
|
{
|
|
List<SelectListItem> result;
|
|
using (var context = new EnVisageEntities())
|
|
{
|
|
result = (from c in context.ExpenditureCategory.AsNoTracking()
|
|
join o in context.Expenditures on c.ExpenditureId equals o.Id
|
|
select new SelectListItem
|
|
{
|
|
Text = c.Expenditure.Name,
|
|
Value = c.Id.ToString(),
|
|
Selected = resourceExpId.HasValue && resourceExpId != Guid.Empty && resourceExpId == c.Id
|
|
}).Distinct().ToList();
|
|
}
|
|
|
|
var r = result.Where(x => x.Selected == true);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get list of the teams for drop-down.
|
|
/// </summary>
|
|
/// <param name="resourceId">Mark team for this resource as selected.</param>
|
|
/// <returns>List of the teams for drop-down list</returns>
|
|
public static IList<SelectListItem> GetTeamsList(Guid? resourceId)
|
|
{
|
|
var list = new List<SelectListItem>();
|
|
|
|
using (var context = new EnVisageEntities())
|
|
{
|
|
list.AddRange(context.Teams.AsNoTracking().Select(x => new SelectListItem()
|
|
{
|
|
Selected = x.PeopleResources.Any(r => r.Id == resourceId),
|
|
Text = x.Name,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTeamExpenditureCategories(Guid? teamId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var expcats = (from r in dbContext.PeopleResources where r.TeamId == teamId select r.ExpenditureCategoryId).Distinct().ToArray();
|
|
retList.AddRange(dbContext.ExpenditureCategory
|
|
.Where(x => expcats.Contains(x.Id))
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.Expenditure.Name,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetResorces()
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var resources = (from r in dbContext.PeopleResources select r).Distinct().ToArray();
|
|
retList.AddRange(resources
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.FirstName + " " + x.LastName,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<string> GetTypeGroups()
|
|
{
|
|
List<string> retList = new List<string>();
|
|
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var resources = (from r in dbContext.TypeGroups select r).Distinct().ToArray();
|
|
retList.AddRange(resources
|
|
.Select(x => x.Name));
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetSubstituteResources(string UserName, Guid CurrentResourceId, Guid ExpenditureCategoryId, Guid ProjectId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
retList.Add(new SelectListItem
|
|
{
|
|
Text = "",
|
|
Value = ""
|
|
});
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var user = dbContext.AspNetUsers.Where(x => x.UserName == UserName).FirstOrDefault();
|
|
var teams = dbContext.User2Team.Where(x => x.UserId == user.Id).Select(x => x.TeamId).ToArray();
|
|
var projectTeamIds = dbContext.Team2Project.Where(x => x.ProjectId == ProjectId).Select(x => x.TeamId).ToArray();
|
|
var resources = dbContext.PeopleResources.Where(x => teams.Contains((Guid)x.TeamId) && projectTeamIds.Contains((Guid)x.TeamId) && x.ExpenditureCategoryId == ExpenditureCategoryId && x.IsActiveEmployee).ToList();
|
|
resources.Remove(resources.Where(x => x.Id == CurrentResourceId).FirstOrDefault());
|
|
retList.AddRange(resources
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.FirstName + " " + x.LastName,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of all principal GUIDs (user himself and his roles) to be used in direct requests to Security and ProjectAccess tables
|
|
/// </summary>
|
|
|
|
private static Guid[] GetUserPrincipals(string userName)
|
|
{
|
|
var result = new Guid[0];
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
AspNetUser user = (from c in dbContext.AspNetUsers where c.UserName == userName select c).FirstOrDefault();
|
|
var roleids = (from c in user.AspNetRoles select c.Id).ToList();
|
|
roleids.Add(user.Id);
|
|
result = new Guid[roleids.Count() + 1];
|
|
for (int i = 0; i < roleids.Count(); i++)
|
|
result[i] = new Guid(roleids[i]);
|
|
result[roleids.Count()] = new Guid(user.Id);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
public static IEnumerable<SelectListItem> GetProjects(string userId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
retList.Add(new SelectListItem
|
|
{
|
|
Text = "",
|
|
Value = ""
|
|
});
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var principals = GetUserPrincipals(userId);
|
|
var projectAccesses = new ProjectAccessCache().Value.Where(x => principals.Contains(x.PrincipalId)).Select(x => x.ProjectId);
|
|
|
|
|
|
List<Project> projects = null;
|
|
var teamIds = new List<Guid>();
|
|
projects = dbContext.Projects.AsNoTracking().Where(p => projectAccesses.Contains(p.Id)).ToList();
|
|
projects.ForEach(p => p.Team2Project.ToList().ForEach(t => teamIds.Add(t.TeamId)));
|
|
|
|
|
|
retList.AddRange(projects
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.Name,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<Project> GetResourceProjects(Guid ResourceId, string Username)
|
|
{
|
|
List<Project> retList = new List<Project>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var userId = dbContext.AspNetUsers.Where(x => x.UserName == Username).Select(x => x.Id).FirstOrDefault();
|
|
var userteams = dbContext.User2Team.Where(x => x.UserId == userId).Select(x => x.TeamId).Distinct().ToList();
|
|
var scenarioIds = dbContext.PeopleResourceAllocations.Where(x => x.PeopleResourceId == ResourceId).Select(x => x.ScenarioId).ToList();
|
|
var ProjectIds = dbContext.Scenarios.Where(x => scenarioIds.Contains(x.Id)).Select(x => x.ParentId).Distinct().ToList();
|
|
var teamsProjectsIds = dbContext.Team2Project.Where(x => ProjectIds.Contains(x.ProjectId) && userteams.Contains(x.TeamId)).Select(x => x.ProjectId).Distinct().ToList();
|
|
var projects = dbContext.Projects.Where(x => ProjectIds.Contains(x.Id)).Distinct().ToList();
|
|
retList.AddRange(projects);
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static List<Contact> GetProjectContacts(Guid projectId)
|
|
{
|
|
List<ContactModel> result = new List<ContactModel>();
|
|
EnVisageEntities DbContext = new EnVisageEntities();
|
|
return (from c in DbContext.Contact2Project where c.ShowId == projectId select c.Contact).Distinct().OrderBy(c => c.LastName).ToList();
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectInternalContacts(Guid? companyId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
if (companyId.HasValue)
|
|
{
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
retList.AddRange(dbContext.Contacts
|
|
.Where(x => x.ParentId == companyId && x.Type == (int)ContactType.CompanyContact)
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.FirstName + " " + x.LastName,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectExternalContacts(Guid? clientId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
if (clientId.HasValue)
|
|
{
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
retList.AddRange(dbContext.Contacts
|
|
.Where(x => x.ParentId == clientId && x.Type == (int)ContactType.ClientContact)
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.FirstName + " " + x.LastName,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static List<ScenarioModel.ProjectItem> GetScenarioProjects(Guid scenarioId)
|
|
{
|
|
List<ScenarioModel.ProjectItem> result;
|
|
using (var context = new EnVisageEntities())
|
|
{
|
|
result = (from p in context.Projects.AsNoTracking()
|
|
select new ScenarioModel.ProjectItem
|
|
{
|
|
Id = p.Id,
|
|
Name = p.Name,
|
|
IsRevenueGenerating = p.IsRevenueGenerating
|
|
}).Distinct().ToList();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string GetLaborMaterialsSplit(Guid scenarioId)
|
|
{
|
|
using (var context = new EnVisageEntities())
|
|
{
|
|
var data = (from sd in context.ScenarioDetail
|
|
join vw in context.VW_Expenditure2Category on sd.ExpenditureCategoryId equals vw.Id
|
|
where sd.ParentID == scenarioId
|
|
select new
|
|
{
|
|
sd.Id,
|
|
sd.Cost,
|
|
ExpenditureType = vw.Type,
|
|
ScenarioId = sd.ParentID,
|
|
}).Distinct().ToArray();
|
|
//var totalBtUpCosts = data.Sum(t => t.Cost);
|
|
var totalBtUpCostsLabor = data.Where(t =>
|
|
t.ExpenditureType == (int)ExpenditureCategoryModel.CategoryTypes.Labor).Sum(x => x.Cost);
|
|
var totalBtUpCostsMaterials = data.Where(t =>
|
|
t.ExpenditureType == (int)ExpenditureCategoryModel.CategoryTypes.Materials).Sum(x => x.Cost);
|
|
if (totalBtUpCostsMaterials == null || totalBtUpCostsMaterials == 0) return "100/0";
|
|
else
|
|
{
|
|
if (totalBtUpCostsLabor == null || totalBtUpCostsLabor == 0) return "N/A";
|
|
var laborslpit = decimal.Round(((totalBtUpCostsLabor/ (totalBtUpCostsLabor + totalBtUpCostsMaterials)) * 100).Value, 1);
|
|
return laborslpit.ToString() + "/" + (100-laborslpit).ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetGLAccounts(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var glAccounts = dbContext.GLAccounts.AsNoTracking();
|
|
options.AddRange(glAccounts.Select(glAccount => new SelectListItem()
|
|
{
|
|
Value = glAccount.Id.ToString(),
|
|
Text = glAccount.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetViews(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var views = dbContext.Views.AsNoTracking();
|
|
options.AddRange(views.Select(view => new SelectListItem()
|
|
{
|
|
Value = view.Id.ToString(),
|
|
Text = view.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetUnitsOfMeasure()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var unitsOfMeasure = dbContext.UOMs.AsNoTracking();
|
|
options.AddRange(unitsOfMeasure.Select(unitOfMeasure => new SelectListItem()
|
|
{
|
|
Value = unitOfMeasure.Id.ToString(),
|
|
Text = unitOfMeasure.Name +" "+ unitOfMeasure.UOMValue.ToString()
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetCreditDepartments(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var creditDepartments = dbContext.CreditDepartments.AsNoTracking().ToList();
|
|
options.AddRange(creditDepartments.Select(creditDepartment => new SelectListItem()
|
|
{
|
|
Value = creditDepartment.Id.ToString(),
|
|
Text = string.IsNullOrEmpty(creditDepartment.CreditNumber) ? creditDepartment.Name : string.Format("{0} ({1})", creditDepartment.Name, creditDepartment.CreditNumber)
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTeams(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var teams = dbContext.Teams.AsNoTracking();
|
|
foreach (Team team in teams)
|
|
{
|
|
options.Add(new SelectListItem()
|
|
{
|
|
Value = team.Id.ToString(),
|
|
Text = team.Name,
|
|
});
|
|
}
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetUsers(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var users = dbContext.AspNetUsers.AsNoTracking();
|
|
options.AddRange(users.Select(user => new SelectListItem()
|
|
{
|
|
Value = user.Id,
|
|
Text = user.UserName
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static string GetUserName(Guid? Id)
|
|
{
|
|
var result = "";
|
|
if (Id.HasValue)
|
|
{
|
|
var ac = new ApplicationDbContext();
|
|
var usermanager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(ac));
|
|
return usermanager.FindById(Id.Value.ToString()).UserName;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetCategoryTypes(bool useEmptyElement = false)
|
|
{
|
|
var result = new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.CategoryTypes.Labor.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.CategoryTypes.Labor.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.CategoryTypes.Materials.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.CategoryTypes.Materials.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.CategoryTypes.Usage.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.CategoryTypes.Usage.ToString()
|
|
}
|
|
};
|
|
if (useEmptyElement)
|
|
result.Insert(0, new SelectListItem());
|
|
return result;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetUseTypes()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.UseTypes.Calculated.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.UseTypes.Calculated.GetHashCode().ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.UseTypes.Cost.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.UseTypes.Cost.GetHashCode().ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.UseTypes.Fee.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.UseTypes.Fee.GetHashCode().ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.UseTypes.Quantity.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.UseTypes.Quantity.GetHashCode().ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetIncomeTypes(bool useEmptyItem = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == (int)SystemAttributeModel.Type.IncomeType);
|
|
options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
|
|
{
|
|
Value = systemAttribute.Id.ToString(),
|
|
Text = systemAttribute.Name
|
|
}));
|
|
}
|
|
if (useEmptyItem)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetCGEFX(bool useEmptyElement = false)
|
|
{
|
|
var result = new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.CgEfx.CG.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.CgEfx.CG.ToDisplayValue()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ExpenditureCategoryModel.CgEfx.EFX.ToDisplayValue(),
|
|
Value = ExpenditureCategoryModel.CgEfx.EFX.ToDisplayValue()
|
|
}
|
|
};
|
|
if (useEmptyElement)
|
|
result.Insert(0, new SelectListItem());
|
|
return result;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTrainingType()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var items = dbContext.TrainingTypes.AsNoTracking().ToArray();
|
|
options.AddRange(items.OrderBy(t => t.Name).Select(item => new SelectListItem()
|
|
{
|
|
Value = item.Id.ToString(),
|
|
Text = item.Name
|
|
}));
|
|
}
|
|
if (options.Count == 0)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetScenarioTypes4Wizard()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = ScenarioType.Portfolio.ToDisplayValue(),
|
|
Value = ScenarioType.Portfolio.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ScenarioType.Scheduling.ToDisplayValue(),
|
|
Value = ScenarioType.Scheduling.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetScenarioTemplates(bool useEmptyElement = false)
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var items = dbContext.Scenarios.AsNoTracking().Where(t => t.Type == (int?)ScenarioType.Template && t.Status == (int?)ScenarioStatus.Active).ToArray();
|
|
options.AddRange(items.OrderBy(t=>t.Name).Select(item => new SelectListItem()
|
|
{
|
|
Value = item.Id.ToString(),
|
|
Text = item.Name
|
|
}));
|
|
}
|
|
if (useEmptyElement)
|
|
options.Insert(0, new SelectListItem());
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetFactorTypes()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = CalculatesCategoryModel.FactorTypes.Divide.ToDisplayValue(),
|
|
Value = CalculatesCategoryModel.FactorTypes.Divide.GetHashCode().ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = CalculatesCategoryModel.FactorTypes.Multipiy.ToDisplayValue(),
|
|
Value = CalculatesCategoryModel.FactorTypes.Multipiy.GetHashCode().ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectStatusDropdown()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var projectStatuses = dbContext.Status.ToList();
|
|
var allItem = new SelectListItem();
|
|
allItem.Text = "All";
|
|
allItem.Value = "All";
|
|
options.Add(allItem);
|
|
options.AddRange(projectStatuses.Select(status => new SelectListItem()
|
|
{
|
|
Value = status.Id.ToString(),
|
|
Text = status.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetProjectClassificationDropdown()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var projectClassifications = dbContext.Types.ToList();
|
|
var allItem = new SelectListItem();
|
|
allItem.Text = "All";
|
|
allItem.Value = "All";
|
|
options.Add(allItem);
|
|
options.AddRange(projectClassifications.Select(classification => new SelectListItem()
|
|
{
|
|
Value = classification.Id.ToString(),
|
|
Text = classification.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetCapacityDropdown()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var scenarios = dbContext.Scenarios.Where(x => x.Type == (int)ScenarioType.Capacity && x.Status == (int)ScenarioStatus.Active).ToList();
|
|
var allItem = new SelectListItem();
|
|
options.AddRange(scenarios.Select(scenario => new SelectListItem()
|
|
{
|
|
Value = scenario.Id.ToString(),
|
|
Text = scenario.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetScenarioGroup()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
var scenarioGroup = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 3).OrderBy(x=>x.Name);
|
|
options.Add(
|
|
new SelectListItem()
|
|
{
|
|
Text = "Default",
|
|
Value = Guid.Empty.ToString()
|
|
}
|
|
);
|
|
options.AddRange(scenarioGroup.Select(group => new SelectListItem()
|
|
{
|
|
Value = group.Id.ToString(),
|
|
Text = group.Name
|
|
}));
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetListboxItems<T>()
|
|
{
|
|
var options = new List<SelectListItem>();
|
|
//if (type is Enum)
|
|
T t = default(T);
|
|
{
|
|
foreach (string e in Enum.GetNames(t.GetType()))
|
|
{
|
|
object value = Enum.Parse(t.GetType(), e);
|
|
|
|
var members = value.GetType().GetMember(value.ToString());
|
|
var attr = members.Length > 0
|
|
? members[0].GetCustomAttributes(typeof(DisplayValueAttribute), true)
|
|
.Cast<DisplayValueAttribute>()
|
|
.FirstOrDefault()
|
|
: null;
|
|
|
|
options.Add(new SelectListItem()
|
|
{
|
|
Text = attr == null ? value.ToString() : attr.DisplayValue,
|
|
Value = value.GetHashCode().ToString()
|
|
});
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetScenarioTypesPortfAndSched()
|
|
{
|
|
return new List<SelectListItem>
|
|
{
|
|
new SelectListItem
|
|
{
|
|
Text = ScenarioType.Portfolio.ToDisplayValue(),
|
|
Value = ScenarioType.Portfolio.ToString()
|
|
},
|
|
new SelectListItem
|
|
{
|
|
Text = ScenarioType.Scheduling.ToDisplayValue(),
|
|
Value = ScenarioType.Scheduling.ToString()
|
|
}
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetContactTypes()
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
foreach (int e in Enum.GetValues(typeof(ContactType)))
|
|
{
|
|
retList.Add(new SelectListItem
|
|
{
|
|
Text = ((ContactType)e).ToDisplayValue(),
|
|
Value = e.ToString(),
|
|
});
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetYesNo()
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
|
|
retList.Add(new SelectListItem()
|
|
{
|
|
Text = "Yes",
|
|
Value = "Yes"
|
|
});
|
|
retList.Add(new SelectListItem()
|
|
{
|
|
Text = "No",
|
|
Value = "No"
|
|
});
|
|
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetContactClassification()
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
|
|
foreach (var classification in Enum.GetValues(typeof(InternalContactClassification)))
|
|
retList.Add(new SelectListItem()
|
|
{
|
|
Text = Enum.GetName(typeof(InternalContactClassification), classification),
|
|
Value = classification.ToString()
|
|
});
|
|
|
|
return retList;
|
|
}
|
|
|
|
public static IEnumerable<SelectListItem> GetTeamContacts(Guid? companyId)
|
|
{
|
|
List<SelectListItem> retList = new List<SelectListItem>();
|
|
|
|
retList.Add(new SelectListItem()
|
|
{
|
|
Text = "None",
|
|
Value = Guid.Empty.ToString()
|
|
});
|
|
|
|
if(companyId.HasValue)
|
|
{
|
|
using (var dbContext = new EnVisageEntities())
|
|
{
|
|
retList.AddRange(dbContext.Contacts
|
|
.Where(x => x.ParentId == companyId &&
|
|
x.ContactClassification == (int)InternalContactClassification.ResourceManagerContact)
|
|
.Select(x => new SelectListItem()
|
|
{
|
|
Text = x.FirstName + " " + x.LastName,
|
|
Value = x.Id.ToString()
|
|
}));
|
|
}
|
|
}
|
|
|
|
return retList;
|
|
}
|
|
|
|
public class DateRange
|
|
{
|
|
public DateTime StartDate { get; set; }
|
|
public DateTime EndDate { get; set; }
|
|
}
|
|
|
|
public static bool IsDateRangesIntersect(DateRange range1, DateRange range2)
|
|
{
|
|
// if ranges are equal - they intersected
|
|
if(range1.StartDate == range2.StartDate && range1.EndDate == range2.EndDate)
|
|
return true;
|
|
|
|
// ranges not intersected if...
|
|
if((range1.StartDate > range2.EndDate) || (range2.StartDate > range1.EndDate))
|
|
return false;
|
|
|
|
// if range1 partially intersect with range2
|
|
if ((range1.StartDate >= range2.StartDate && range1.StartDate < range2.EndDate)
|
|
|| (range2.StartDate >= range1.StartDate && range2.StartDate < range1.EndDate))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a multiplier to be applied to scenario detail quantity or rate, value depends on provided expenditure category's UOM value.
|
|
/// </summary>
|
|
/// <param name="expCatId">Expenditure Category Id.</param>
|
|
/// <param name="uomMode">Value indicating selected UOM Mode.<br/>
|
|
/// null - UOM Mode has not been selected. Use default value = 1;<br/>
|
|
/// true - UOM Mode is Hours. Returned value is 1.
|
|
/// false - UOM Mode is Resources. Returned value depends on provided expenditure category Id.
|
|
/// </param>
|
|
/// <param name="categories">Dictionary of all available expenditure categories used as source to search for provided <paramref name="expCatId"/>. Key is Category.Id</param>
|
|
/// <param name="uoms">Dictionary of all Unit of Measures used as a source to search for UOM value. Key is UoM.Id</param>
|
|
/// <returns>Returns a decimal multiplier value depending on provided expenditure category's UOM value.</returns>
|
|
public static decimal GetUOMMultiplier(Dictionary<Guid, ExpenditureCategory> categories, Dictionary<Guid, UOM> uoms, Guid expCatId, bool? uomMode)
|
|
{
|
|
if (!uomMode.HasValue || uomMode.Value)
|
|
return Constants.UOM_HOURS_MULTIPLIER;
|
|
|
|
if (categories == null || !categories.Any() || uoms == null || !uoms.Any())
|
|
throw new UOMNotExistsException();
|
|
|
|
ExpenditureCategory category = null;
|
|
if (categories.ContainsKey(expCatId))
|
|
category = categories[expCatId];
|
|
if (category == null)
|
|
throw new UOMNotExistsException();
|
|
|
|
UOM uom = null;
|
|
if (uoms.ContainsKey(category.UOMId))
|
|
uom = uoms[category.UOMId];
|
|
if (uom == null || uom.UOMValue == 0)
|
|
throw new UOMNotExistsException();
|
|
|
|
return 1 / uom.UOMValue;
|
|
}
|
|
|
|
[Obsolete("Use new GetUOMMultiplier with dictionaries instead of this one")]
|
|
public static decimal GetUOMMultiplier(IEnumerable<ExpenditureCategory> categories, IEnumerable<UOM> uoms, Guid expCatId, bool? uomMode)
|
|
{
|
|
if (!uomMode.HasValue || uomMode.Value)
|
|
return Constants.UOM_HOURS_MULTIPLIER;
|
|
|
|
if (categories == null || !categories.Any() || uoms == null || !uoms.Any())
|
|
throw new UOMNotExistsException();
|
|
|
|
var cat = categories.FirstOrDefault(t => t.Id == expCatId);
|
|
if (cat == null)
|
|
throw new UOMNotExistsException();
|
|
var uom = uoms.FirstOrDefault(t => t.Id == cat.UOMId);
|
|
if (uom == null || uom.UOMValue == 0)
|
|
throw new UOMNotExistsException();
|
|
|
|
return 1 / uom.UOMValue;
|
|
}
|
|
|
|
|
|
}
|
|
} |