/// <summary>
/// پست سازمانی دسته ای از پرسنل را برمیگرداند
/// </summary>
/// <param name="personIds"></param>
/// <returns></returns>
public IList <OrganizationUnit> GetOrganizationUsnitByPersonIds(IList <decimal> personIds)
{
IList <decimal> accessableIDs = personIds;
IList <OrganizationUnit> organizationUnitList = new List <OrganizationUnit>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
organizationUnitList = GetByCriteria(new CriteriaStruct(Utility.Utility.GetPropertyName(() => new OrganizationUnit().Person.ID), personIds.ToArray(), CriteriaOperation.IN));
}
else
{
OrganizationUnit organizationUnitAlias = null;
Person personAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
TempRepository tempRep = new TempRepository(false);
string operationGUID = tempRep.InsertTempList(accessableIDs);
organizationUnitList = NHSession.QueryOver <OrganizationUnit>(() => organizationUnitAlias)
.JoinAlias(() => organizationUnitAlias.Person, () => personAlias)
.JoinAlias(() => personAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <OrganizationUnit>();
tempRep.DeleteTempList(operationGUID);
}
return(organizationUnitList);
}
/// <summary>
/// اگر پرسنل با شناسه های ورودی نیاز به محاسبه داشت آن را در قالب شی "پرسنل قابل محاسبه" برمی گرداند
/// اگر تاریخ آخرین محاسبه پرسنل کوچکتر از تاریخ ورودی بود یا محاسباتش نا معتبر بود، آن پرسنل برای محاسبه واکشی می گردد
/// </summary>
/// <param name="PrsId"></param>
/// <param name="Date"></param>
/// <returns></returns>
public IList <ExecutablePersonCalculation> GetAllByPrsIds(IList <decimal> Persons, DateTime Date)
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
TempRepository tempRep = new TempRepository(false);
string operationGUID = tempRep.InsertTempList(Persons);
GTS.Clock.Model.Temp.Temp tempObjAlias = null;
ExecutablePersonCalculation cfpAlias = null;
Person personAlias = null;
var tmpList = QueryOver.Of <GTS.Clock.Model.Temp.Temp>(() => tempObjAlias)
.Where(() => tempObjAlias.ObjectID == cfpAlias.PersonId)
.And(() => tempObjAlias.OperationGUID == operationGUID)
.Select(x => x.ObjectID);
IList <ExecutablePersonCalculation> result = NHibernateSession.QueryOver(() => cfpAlias)
.Where(x => (x.FromDate < Date.Date) || (x.FromDate == Date.Date && !x.CalculationIsValid))
.WithSubquery
.WhereExists(tmpList)
.List <ExecutablePersonCalculation>();
tempRep.DeleteTempList(operationGUID);
return(result);
//return NHibernateSession.QueryOver<ExecutablePersonCalculation>()
// .Where(x => !x.CalculationIsValid)
// .AndRestrictionOn(x => x.PersonId).IsIn(Persons.ToArray<decimal>())
// .List<ExecutablePersonCalculation>();
}
public IList <Precard> GetAllByPrecardGroup(decimal precadGrpId)
{
IList <decimal> accessableIDs = accessPort.GetAccessiblePrecards();
IList <Precard> list = new List <Precard>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = precardRep.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new Precard().PrecardGroup), new PrecardGroups()
{
ID = precadGrpId
}),
new CriteriaStruct(Utility.GetPropertyName(() => new Precard().ID), accessableIDs.ToArray(), CriteriaOperation.IN));
}
else
{
Precard precardAlias = null;
PrecardGroups precardGroupsAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => precardAlias)
.JoinAlias(() => precardAlias.TempList, () => tempAlias)
.JoinAlias(() => precardAlias.PrecardGroup, () => precardGroupsAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && precardAlias.PrecardGroup.ID == precadGrpId)
.List <Precard>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
/// <summary>
/// کلیه سرانه های اضافه کار تشویقی, شب کاری تشویقی, تعطیل کار تشویقی را بر می گرداند
/// بر اساس دسترسی کاربر به دپارتمان
/// </summary>
/// <returns>لیست پروکسی سرانه</returns>
public override IList <OverTimeDetail> GetAll()
{
OverTime overTimeAlias = null;
OverTimeDetail overTimeDetailAlias = null;
Department departmentAlias = null;
IList <OverTimeDetail> list = new List <OverTimeDetail>();
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.Where(() => departmentAlias.ID.IsIn(accessableIDs.ToList()) && overTimeAlias.IsActive == true)
.List <OverTimeDetail>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && overTimeAlias.IsActive == true)
.List <OverTimeDetail>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
/// <summary>
/// برای بایند شدن درخت در هنگام باز کردن گره این تابع استفاده میشود
/// </summary>
/// <param name="parentId">کلید ریشه</param>
/// <returns>لیست پست سازمانی</returns>
public IList <OrganizationUnit> GetChilds(decimal parentId)
{
try
{
IList <OrganizationUnit> list = null;
IList <decimal> accessableIDs = accessPort.GetAccessibleOrgans();
if (accessableIDs.Count < this.OperationBatchSizeValue && this.OperationBatchSizeValue < 2100)
{
list = NHSession.QueryOver <OrganizationUnit>()
.Where(x => x.ID.IsIn(accessableIDs.ToArray()) &&
x.Parent.ID == parentId
)
.List <OrganizationUnit>();
}
else
{
OrganizationUnit organizationAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => organizationAlias)
.JoinAlias(() => organizationAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && organizationAlias.Parent.ID == parentId)
.List <OrganizationUnit>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
catch (Exception ex)
{
LogException(ex, "BOrganizationUnit", "GetChilds");
throw ex;
}
}
/// <summary>
/// لیست مراکز هزینه را بر اساس دسترسی کاربر به آن بر می گرداند
/// </summary>
/// <returns>لیست مراکز هزینه</returns>
public override IList <CostCenter> GetAll()
{
IList <CostCenter> costCenters = new List <CostCenter>();
try
{
IList <decimal> accessableIDs = accessPort.GetAccessibleCostCenters();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
costCenters = CostCenterRepository.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new CostCenter().ID), accessableIDs.ToArray(), CriteriaOperation.IN));
}
else
{
CostCenter costCenterAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
costCenters = NHSession.QueryOver(() => costCenterAlias)
.JoinAlias(() => costCenterAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <CostCenter>();
this.bTemp.DeleteTempList(operationGUID);
}
return(costCenters);
}
catch (Exception ex)
{
LogException(ex, "BCostCenter", "GetAll");
throw ex;
}
finally { }
}
/// <summary>
/// جستجوی پست سازمانی
/// </summary>
/// <param name="searchVal">عبارت جستجو</param>
/// <returns>لیست پست سازمانی</returns>
public IList <OrganizationUnit> SearchOrganizationUnit(string searchVal)
{
try
{
IList <OrganizationUnit> list = null;
IList <decimal> accessableIDs = accessPort.GetAccessibleOrgans();
if (accessableIDs.Count < this.OperationBatchSizeValue && this.OperationBatchSizeValue < 2100)
{
list = NHSession.QueryOver <OrganizationUnit>()
.Where(x => x.ID.IsIn(accessableIDs.ToArray()) &&
(x.Name.IsInsensitiveLike(searchVal, MatchMode.Anywhere) || x.CustomCode.IsInsensitiveLike(searchVal, MatchMode.Anywhere))
)
.List <OrganizationUnit>();
}
else
{
OrganizationUnit organizationAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => organizationAlias)
.JoinAlias(() => organizationAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && (organizationAlias.Name.IsInsensitiveLike(searchVal, MatchMode.Anywhere) || organizationAlias.CustomCode.IsInsensitiveLike(searchVal, MatchMode.Anywhere)))
.List <OrganizationUnit>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
catch (Exception ex)
{
LogException(ex, "BOrganizationUnit", "SearchOrganizationUnit");
throw ex;
}
}
public IList <OrganizationUnit> GetParentOrganizationPosts(int postId)
{
OrganizationUnit organizationUnitAlias = null;
IList <OrganizationUnit> ParentOrganizationUnitList = new List <OrganizationUnit>();
OrganizationUnit PostList = NHSession.QueryOver <OrganizationUnit>()
.Where(x => x.ID == postId)
.SingleOrDefault();
if (PostList != null)
{
if (PostList.ParentPathList.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
ParentOrganizationUnitList = NHSession.QueryOver(() => organizationUnitAlias)
.Where(() => organizationUnitAlias.ID.IsIn(PostList.ParentPathList.ToArray()))
.List <OrganizationUnit>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(PostList.ParentPathList);
ParentOrganizationUnitList = NHSession.QueryOver(() => organizationUnitAlias)
.JoinAlias(() => organizationUnitAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <OrganizationUnit>();
this.bTemp.DeleteTempList(operationGUID);
}
}
return(ParentOrganizationUnitList);
}
public override IList <WorkGroup> GetAll()
{
try
{
IList <WorkGroup> list = null;
IList <decimal> accessableIDs = accessPort.GetAccessibleWorkGroups();
if (accessableIDs.Count < this.OperationBatchSizeValue && this.OperationBatchSizeValue < 2100)
{
list = NHSession.QueryOver <WorkGroup>()
.Where(x => x.ID.IsIn(accessableIDs.ToArray()))
.List <WorkGroup>();
}
else
{
WorkGroup workGroupAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => workGroupAlias)
.JoinAlias(() => workGroupAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <WorkGroup>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
catch (Exception ex)
{
LogException(ex, "BWorkgroup", "GetAll");
throw ex;
}
}
/// <summary>
/// واکشی بخش ها بر اساس دسترسی کاربر جاری به بخش
/// </summary>
/// <returns></returns>
public override IList <Department> GetAll()
{
try
{
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
IList <Department> list = new List <Department>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = NHSession.QueryOver <Department>().Where(d => d.ID.IsIn(accessableIDs.ToList())).List <Department>();
}
else
{
Department departmentAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <Department>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
/// <summary>
/// لیست ایستگاه های کنترل را بر می گرداند
/// </summary>
/// <returns>لیست ایستگاه کنترل</returns>
public override IList <ControlStation> GetAll()
{
IList <decimal> accessableIDs = accessPort.GetAccessibleControlStations();
IList <ControlStation> list = new List <ControlStation>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = staionRepository.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new ControlStation().ID), accessableIDs.ToArray(), CriteriaOperation.IN));
}
else
{
ControlStation controlStationAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => controlStationAlias)
.JoinAlias(() => controlStationAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <ControlStation>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
/// <summary>
/// تردد های لیست پرسنل در یک بازه زمانی مشخص را بر می گرداند
/// </summary>
/// <param name="personListId">لیست کلید اصلی پرسنلی</param>
/// <param name="precardListId">لیست کلید اصلی پیش کارت</param>
/// <param name="fromDate">تاریخ شروع</param>
/// <param name="toDate">تاریخ پایان</param>
/// <returns>لیست ترددها</returns>
public IList <BasicTraffic> GetTrafficPersons(IList <decimal> personListId, IList <decimal> precardListId, DateTime fromDate, DateTime toDate)
{
try
{
BasicTraffic basicTrafficAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
Person personAlias = null;
string operationGUID = this.bTemp.InsertTempList(personListId);
IList <BasicTraffic> basicList = NHibernateSessionManager.Instance.GetSession().
QueryOver <BasicTraffic>(() => basicTrafficAlias)
.JoinAlias(() => basicTrafficAlias.Person, () => personAlias)
.JoinAlias(() => personAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.And(() => basicTrafficAlias.Precard.ID.IsIn(precardListId.ToArray()))
.And(() => basicTrafficAlias.Date >= fromDate)
.And(() => basicTrafficAlias.Date <= toDate)
.And(() => basicTrafficAlias.Active).List <BasicTraffic>();
this.bTemp.DeleteTempList(operationGUID);
return(basicList);
}
catch (Exception ex)
{
LogException(ex, "BTraffic", "TrafficIsExist");
throw ex;
}
}
public IList <ArchiveConceptValue> LoadArchiveValueList(IList <decimal> personList, int year, int rangeOrder)
{
personList = base.CheckListParameter(personList).ToList();
ArchiveConceptValue cnpValues = null;
SecondaryConcept concept = null;
Person personAlias = null;
IList <decimal> accessableIDs = personList;
IList <ArchiveConceptValue> result = new List <ArchiveConceptValue>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
result = NHibernateSession.QueryOver <ArchiveConceptValue>(() => cnpValues)
.JoinAlias(() => cnpValues.Person, () => personAlias)
.Where(() => cnpValues.RangeOrder == rangeOrder)
.And(() => cnpValues.Year == year)
.And(() => personAlias.ID.IsIn(personList.ToArray()))
.List();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
TempRepository tempRep = new TempRepository(false);
string operationGUID = tempRep.InsertTempList(accessableIDs);
result = NHibernateSession.QueryOver <ArchiveConceptValue>(() => cnpValues)
.JoinAlias(() => cnpValues.Person, () => personAlias)
.JoinAlias(() => personAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.And(() => cnpValues.RangeOrder == rangeOrder)
.And(() => cnpValues.Year == year)
.List();
tempRep.DeleteTempList(operationGUID);
}
return(result);
}
public IList <Department> GetParentDepartments(int departmentId)
{
Department departmentAlias = null;
IList <Department> ParentDepartmentsList = new List <Department>();
Department DepList = NHSession.QueryOver <Department>()
.Where(x => x.ID == departmentId)
.SingleOrDefault();
if (DepList != null)
{
if (DepList.ParentPathList.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
ParentDepartmentsList = NHSession.QueryOver(() => departmentAlias)
.Where(() => departmentAlias.ID.IsIn(DepList.ParentPathList.ToArray()))
.List <Department>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(DepList.ParentPathList);
ParentDepartmentsList = NHSession.QueryOver(() => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <Department>();
this.bTemp.DeleteTempList(operationGUID);
}
}
return(ParentDepartmentsList);
}
public IList <RuleTemplate> GetRuleTemplates(decimal[] ruleTemplateIds)
{
if (ruleTemplateIds == null)
{
return(new List <RuleTemplate>());
}
RuleTemplate ruleTemplateAlias = null;
IList <decimal> accessableIDs = ruleTemplateIds;
IList <RuleTemplate> result = new List <RuleTemplate>();
IList <RuleTemplate> ruleTemplateList = new List <RuleTemplate>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
ruleTemplateList = NHibernateSession.QueryOver <RuleTemplate>()
.WhereRestrictionOn(x => x.ID)
.IsIn(ruleTemplateIds)
.List <RuleTemplate>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
TempRepository tempRep = new TempRepository(false);
string operationGUID = tempRep.InsertTempList(accessableIDs);
ruleTemplateList = NHibernateSession.QueryOver <RuleTemplate>(() => ruleTemplateAlias)
.JoinAlias(() => ruleTemplateAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <RuleTemplate>();
tempRep.DeleteTempList(operationGUID);
}
return(ruleTemplateList);
}
public IList <RuleCategory> GetRuleCategoryChilds(decimal parentId)
{
try
{
IList <decimal> accessableIDs = accessPort.GetAccessibleRuleGroups();
IList <RuleCategory> list = new List <RuleCategory>();
RuleCategory ruleCatAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = RuleCategoryRep.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new RuleCategory().ParentId), parentId),
new CriteriaStruct(Utility.GetPropertyName(() => new RuleCategory().ID), accessableIDs.ToArray(), CriteriaOperation.IN),
new CriteriaStruct(Utility.GetPropertyName(() => new RuleCategory().SubSystemId), SubSystemIdentifier.TimeAtendance));
}
else
{
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => ruleCatAlias)
.JoinAlias(() => ruleCatAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && ruleCatAlias.ParentId == parentId && ruleCatAlias.SubSystemId == SubSystemIdentifier.TimeAtendance)
.List <RuleCategory>();
this.bTemp.DeleteTempList(operationGUID);
}
// IList<ReportParameter> parameters = reportParameterRep.GetAll();
//foreach (RuleCategory report in list)
//{
// if (report.IsReport && !report.IsDesignedReport)
// {
// report.HasParameter = this.HasReportParameter(report.ReportFile.ID, parameters);
// }
// if (report.IsDesignedReport)
// report.HasParameter = true;
//}
List <RuleCategory> result = new List <RuleCategory>();
result.AddRange(list.Where(x => x.IsGroup).OrderBy(x => x.IsGroup));
result.AddRange(list.Where(x => !x.IsGroup).OrderBy(x => x.IsGroup));
return(result);
}
catch (Exception ex)
{
LogException(ex, "BRulesGroup", "GetRulesGroupChilds");
throw ex;
}
}
public IList <decimal> GetExsitsArchivePersons(IList <decimal> personList, int Year, int rangeOrder)
{
personList = base.CheckListParameter(personList).ToList();
ArchiveConceptValue cnpValues = null;
Person personAlias = null;
IList <decimal> accessableIDs = personList;
IList <object[]> result = new List <object[]>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
result = NHibernateSession
.QueryOver <ArchiveConceptValue>(() => cnpValues)
.JoinAlias(() => cnpValues.Person, () => personAlias)
.Where(() => cnpValues.RangeOrder == rangeOrder)
.And(() => cnpValues.Year == Year)
.And(() => personAlias.ID.IsIn(personList.ToArray()))
.Select
(
Projections.Group <ArchiveConceptValue>(x => x.PersonId),
Projections.Count <ArchiveConceptValue>(x => x.PersonId)
)
.List <object[]>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
TempRepository tempRep = new TempRepository(false);
string operationGUID = tempRep.InsertTempList(accessableIDs);
result = NHibernateSession
.QueryOver <ArchiveConceptValue>(() => cnpValues)
.JoinAlias(() => cnpValues.Person, () => personAlias)
.JoinAlias(() => personAlias.TempList, () => tempAlias)
.Where(() => cnpValues.RangeOrder == rangeOrder)
.And(() => cnpValues.Year == Year)
.Select
(
Projections.Group <ArchiveConceptValue>(x => x.PersonId),
Projections.Count <ArchiveConceptValue>(x => x.PersonId)
)
.List <object[]>();
tempRep.DeleteTempList(operationGUID);
}
var persons = from o in result
select(decimal) o.First();
return(persons.ToList());
}
/// <summary>
/// جستجوی بخش ها
/// </summary>
/// <param name="field">فیلد مورد نظر جهت جستجو</param>
/// <param name="searchVal">عبارت جستجو</param>
/// <returns>لیست بخش ها</returns>
public IList <Department> SearchDepartment(DepartmentSearchFields field, string searchVal)
{
try
{
IList <Department> list = new List <Department>();
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
switch (field)
{
case DepartmentSearchFields.DepartmentName:
case DepartmentSearchFields.NotSpec:
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list =
NHibernateSessionManager.Instance.GetSession().QueryOver <Department>()
.Where(x => x.ID.IsIn(accessableIDs.ToList()) &&
(x.Name.IsInsensitiveLike(searchVal, MatchMode.Anywhere) || x.CustomCode.IsInsensitiveLike(searchVal, MatchMode.Anywhere))
)
.List <Department>();
}
else
{
Department departmentAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID &&
(departmentAlias.Name.IsInsensitiveLike(searchVal, MatchMode.Anywhere) || (departmentAlias.CustomCode.IsInsensitiveLike(searchVal, MatchMode.Anywhere))))
.List <Department>();
this.bTemp.DeleteTempList(operationGUID);
}
break;
}
return(list);
}
catch (Exception ex)
{
LogException(ex, "BDepartment", "SearchDepartment");
throw ex;
}
}
/// <summary>
/// لیست همه شیفتها را برمیگرداند
/// اگر نوبت کاری نداشته باشد بمنظور نمایش در یو آی یک نوبت کاری صوری میسازد
/// </summary>
/// <returns></returns>
public override IList <Shift> GetAll()
{
IList <Shift> shifts = new List <Shift>();
try
{
IList <decimal> accessableIDs = accessPort.GetAccessibleShifts();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
shifts = shiftRepository.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new Shift().ID), accessableIDs.ToArray(), CriteriaOperation.IN));
}
else
{
Shift shiftAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
shifts = NHSession.QueryOver(() => shiftAlias)
.JoinAlias(() => shiftAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <Shift>();
this.bTemp.DeleteTempList(operationGUID);
}
for (int i = 0; i < shifts.Count; i++)
{
if (shifts[i].NobatKari == null)
{
shifts[i].NobatKari = new NobatKari();
}
}
return(shifts);
}
catch (Exception ex)
{
LogException(ex, "BShift", "GetAll");
throw ex;
}
finally { }
}
/// <summary>
/// زیر بخش های یک بخش را بر اساس دسترسی کاربر جاری به بخش ها برمی گرداند
/// </summary>
/// <param name="departmentId">کلید اصلی بخش</param>
/// <returns>لیست بخش</returns>
public IList <Department> GetDepartmentChilds(decimal departmentId)
{
try
{
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
IList <Department> depList = new List <Department>();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
depList = departmentRepository
.GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new Department().Parent), new Department()
{
ID = departmentId
}),
new CriteriaStruct(Utility.GetPropertyName(() => new Department().ID), accessableIDs.ToArray(), CriteriaOperation.IN));
}
else
{
Department departmentAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
depList = NHSession.QueryOver(() => departmentAlias)
//.JoinAlias(() => departmentAlias.Parent, () => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && departmentAlias.Parent.ID == departmentId)
.List <Department>();
this.bTemp.DeleteTempList(operationGUID);
}
if (depList != null && depList.Count > 0)
{
depList = depList.OrderBy(x => x.CustomCode).ToList();
}
return(depList);
}
catch (Exception ex)
{
LogException(ex, "BDepartment", "GetDepartmentChilds");
throw ex;
}
}
public override IList <RuleCategory> GetAll()
{
IList <RuleCategory> list = null;
IList <decimal> accessableIDs = accessPort.GetAccessibleRuleGroups();
if (accessableIDs.Count < this.OperationBatchSizeValue && this.OperationBatchSizeValue < 2100)
{
list = NHSession.QueryOver <RuleCategory>()
.Where(x => x.ID.IsIn(accessableIDs.ToArray()))
.List <RuleCategory>();
}
else
{
RuleCategory ruleCategoryAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = this.NHSession.QueryOver(() => ruleCategoryAlias)
.JoinAlias(() => ruleCategoryAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <RuleCategory>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
public void UpdateSubstitutePrecardAccessByFlow(IList <decimal> flowIDsList)
{
try
{
string SQLCommand = string.Empty;
IQuery query = null;
Flow flowAlias = null;
ManagerFlow managerFlowAlias = null;
Manager managerAlias = null;
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = string.Empty;
BTemp bTemp = new BTemp();
IList <Manager> managersList = new List <Manager>();
if (flowIDsList.Count() < operationBatchSizeValue && operationBatchSizeValue < 2100)
{
managersList = this.NHSession.QueryOver <Manager>(() => managerAlias)
.JoinAlias(() => managerAlias.ManagerFlowList, () => managerFlowAlias)
.JoinAlias(() => managerFlowAlias.Flow, () => flowAlias)
.Where(() => flowAlias.ID.IsIn(flowIDsList.ToArray()))
.List <Manager>();
}
else
{
operationGUID = bTemp.InsertTempList(flowIDsList);
managersList = this.NHSession.QueryOver <Manager>(() => managerAlias)
.JoinAlias(() => managerAlias.ManagerFlowList, () => managerFlowAlias)
.JoinAlias(() => managerFlowAlias.Flow, () => flowAlias)
.JoinAlias(() => flowAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID)
.List <Manager>();
bTemp.DeleteTempList(operationGUID);
operationGUID = string.Empty;
}
if (managersList != null && managersList.Count > 0)
{
if (managersList.Count() < operationBatchSizeValue && operationBatchSizeValue < 2100)
{
SQLCommand = @"
DELETE FROM dbo.TA_SubstitutePrecardAccess
WHERE subaccess_SubstituteId IN (
SELECT sub_ID FROM dbo.TA_Substitute
INNER JOIN dbo.TA_SubstitutePrecardAccess ON sub_ID = subaccess_SubstituteId
WHERE sub_ManagerId IN (:managerIdsList)
)";
query = this.NHSession.CreateSQLQuery(SQLCommand);
query.SetParameterList("managerIdsList", managersList.Select(x => x.ID).ToArray());
query.ExecuteUpdate();
SQLCommand = @"
INSERT INTO dbo.TA_SubstitutePrecardAccess
( subaccess_PrecardId ,
subaccess_SubstituteId
)
SELECT precard.Precrd_ID, substitute.sub_ID FROM dbo.TA_Manager manager
INNER JOIN dbo.TA_Substitute substitute ON manager.MasterMng_ID = substitute.sub_ManagerId
INNER JOIN dbo.TA_ManagerFlow managerFlow ON manager.MasterMng_ID = managerFlow.mngrFlow_ManagerID
INNER JOIN dbo.TA_Flow flow ON managerFlow.mngrFlow_FlowID = flow.Flow_ID
INNER JOIN dbo.TA_PrecardAccessGroup precardAccessGroup ON flow.Flow_AccessGroupID = precardAccessGroup.accessGrp_ID
INNER JOIN dbo.TA_PrecardAccessGroupDetail precardAccessGroupDetail ON precardAccessGroup.accessGrp_ID = precardAccessGroupDetail.accessGrpDtl_AccessGrpId
INNER JOIN dbo.TA_Precard precard ON precardAccessGroupDetail.accessGrpDtl_PrecardId = precard.Precrd_ID
WHERE flow.Flow_Deleted = 0 AND
flow.Flow_ActiveFlow = 1 AND
manager.MasterMng_Active = 1 AND
managerFlow.mngrFlow_Active = 1 AND
substitute.sub_ManagerId IN (:managerIdsList)";
query = this.NHSession.CreateSQLQuery(SQLCommand);
query.SetParameterList("managerIdsList", managersList.Select(x => x.ID).ToArray());
query.ExecuteUpdate();
}
else
{
operationGUID = bTemp.InsertTempList(managersList.Select(x => x.ID).ToList <decimal>());
SQLCommand = @"
DELETE FROM dbo.TA_SubstitutePrecardAccess
WHERE subaccess_SubstituteId IN (
SELECT sub_ID FROM dbo.TA_Substitute
INNER JOIN dbo.TA_SubstitutePrecardAccess ON sub_ID = subaccess_SubstituteId
INNER JOIN dbo.TA_Temp ON sub_ID = temp_ObjectID
WHERE temp_OperationGUID = :operationGUID
)
";
query = this.NHSession.CreateSQLQuery(SQLCommand);
query.SetParameter("operationGUID", operationGUID);
query.ExecuteUpdate();
SQLCommand = @"
INSERT INTO dbo.TA_SubstitutePrecardAccess
( subaccess_PrecardId ,
subaccess_SubstituteId
)
SELECT precard.Precrd_ID, substitute.sub_ID FROM dbo.TA_Manager manager
INNER JOIN dbo.TA_Substitute substitute ON manager.MasterMng_ID = substitute.sub_ManagerId
INNER JOIN dbo.TA_ManagerFlow managerFlow ON manager.MasterMng_ID = managerFlow.mngrFlow_ManagerID
INNER JOIN dbo.TA_Flow flow ON managerFlow.mngrFlow_FlowID = flow.Flow_ID
INNER JOIN dbo.TA_PrecardAccessGroup precardAccessGroup ON flow.Flow_AccessGroupID = precardAccessGroup.accessGrp_ID
INNER JOIN dbo.TA_PrecardAccessGroupDetail precardAccessGroupDetail ON precardAccessGroup.accessGrp_ID = precardAccessGroupDetail.accessGrpDtl_AccessGrpId
INNER JOIN dbo.TA_Precard precard ON precardAccessGroupDetail.accessGrpDtl_PrecardId = precard.Precrd_ID
INNER JOIN dbo.TA_Temp temp ON sub_ID = temp.temp_OperationGUID
WHERE flow.Flow_Deleted = 0 AND
flow.Flow_ActiveFlow = 1 AND
manager.MasterMng_Active = 1 AND
managerFlow.mngrFlow_Active = 1 AND
temp.temp_OperationGUID = :operationGUID
";
query = this.NHSession.CreateSQLQuery(SQLCommand);
query.SetParameter("operationGUID", operationGUID);
query.ExecuteUpdate();
bTemp.DeleteTempList(operationGUID);
}
}
}
catch (Exception ex)
{
LogException(ex, ExceptionSrc, "UpdateSubstitutePrecardAccessByFlow");
}
}
private void DeleteSuspendRequestStatesByFlowCondition(decimal flowID, IList <ManagerFlowConditionPrecardProxy> managerFlowConditionPreacardProxyList)
{
try
{
Request requestAlias = null;
RequestStatus requestStatusAlias = null;
ManagerFlow managerFlowAlias = null;
Flow flowAlias = null;
GTS.Clock.Model.Temp.Temp precardAccessGroupDetailTempAlias = null;
PrecardAccessGroup precardAccessGroupAlias = null;
PrecardAccessGroupDetail precardAccessGroupDetailAlias = null;
string precardAccessGroupDetailOperationGUID = string.Empty;
string requestStatusOperationGUID = string.Empty;
List <decimal> requestStatusIdsList = new List <decimal>();
BTemp tempBusiness = new BTemp();
precardAccessGroupDetailOperationGUID = tempBusiness.InsertTempList(managerFlowConditionPreacardProxyList.Select(x => x.ManagerFlowCondition.PrecardAccessGroupDetail.ID).ToList <decimal>());
var EndFlowAndDeletedRequestStatusSubQuery = QueryOver.Of <RequestStatus>(() => requestStatusAlias)
.Where(() => requestStatusAlias.EndFlow || !requestStatusAlias.IsDeleted)
.And(() => requestStatusAlias.Request.ID == requestAlias.ID)
.Select(x => x.ID);
IList <Request> requestsList = this.NHSession.QueryOver <Request>(() => requestAlias)
.JoinAlias(() => requestAlias.RequestStatusList, () => requestStatusAlias)
.JoinAlias(() => requestStatusAlias.ManagerFlow, () => managerFlowAlias)
.JoinAlias(() => managerFlowAlias.Flow, () => flowAlias)
.JoinAlias(() => flowAlias.AccessGroup, () => precardAccessGroupAlias)
.JoinAlias(() => precardAccessGroupAlias.PrecardAccessGroupDetailList, () => precardAccessGroupDetailAlias)
.JoinAlias(() => precardAccessGroupDetailAlias.TempList, () => precardAccessGroupDetailTempAlias)
.Where(() => !flowAlias.IsDeleted &&
!requestAlias.EndFlow &&
flowAlias.ID == flowID &&
precardAccessGroupDetailTempAlias.OperationGUID == precardAccessGroupDetailOperationGUID
)
.WithSubquery
.WhereNotExists(EndFlowAndDeletedRequestStatusSubQuery)
.List <Request>();
tempBusiness.DeleteTempList(precardAccessGroupDetailOperationGUID);
foreach (Request requestItem in requestsList)
{
ManagerFlowConditionPrecardProxy managerFlowConditionPrecardProxy = managerFlowConditionPreacardProxyList.Where(x => x.PrecardID == requestItem.ID).FirstOrDefault();
if (this.CheckRequestValueAppliedFlowConditionValue(managerFlowConditionPrecardProxy.ManagerFlowCondition, requestItem))
{
requestStatusIdsList.AddRange(requestItem.RequestStatusList.Select(x => x.ID).ToList <decimal>());
}
}
if (requestStatusIdsList.Count > 0)
{
requestStatusOperationGUID = tempBusiness.InsertTempList(requestStatusIdsList);
string SQLCommand = @"delete from TA_RequestStatus
inner join TA_Temp
on reqStat_ID = temp_OperationGUID
where temp_OperationGUID = :operationGUID";
NHSession.CreateSQLQuery(SQLCommand)
.SetParameter("operationGUID", requestStatusOperationGUID)
.ExecuteUpdate();
tempBusiness.DeleteTempList(requestStatusOperationGUID);
}
}
catch (Exception ex)
{
LogException(ex, "BManagerFlowCondition", "DeleteSuspendRequestStatesByFlowCondition");
throw;
}
}
/// <summary>
/// سرانه های اضافه کار تشویقی, شب کاری تشویقی, تعطیل کار تشویقی مربوط به ماه/سال مشخص به صورت صفحه بندی شده بر می گرداند
/// بر اساس دسترسی کاربر به دپارتمان
/// </summary>
/// <param name="parentDepartmentId">آی دی ارگان/سازمان جهت جستجو</param>
/// <param name="departmentName">نام معاونت جهت جستجو</param>
/// <param name="year">سال</param>
/// <param name="month">ماه</param>
/// <param name="pageIndex">ایندکس صفحه</param>
/// <param name="pageSize">اندازه صفحه</param>
/// <param name="count">تعداد کل رکوردها بدون صفحه بندی</param>
/// <returns>لیست پروکسی سرانه</returns>
public IList <OverTimeProxy> GetDetails(decimal parentDepartmentId, string departmentName, int year, int month, int pageIndex, int pageSize, out int count)
{
DateTime Date;
if (BLanguage.CurrentSystemLanguage == LanguagesName.Parsi)
{
Date = Utility.ToMildiDate(String.Format("{0}/{1}/{2}", year, month, 1));
}
else
{
Date = new DateTime(year, month, 1);
}
//-----------------------------------------------------------------
//چک کن اگه موجودیت والد برای این ماه/سال در دیتابیس وجود نداشت, یه موجودیت والد ذخیره کن
this.CheckOverTimeExists(Date);
//-----------------------------------------------------------------
OverTime overTimeAlias = null;
OverTimeDetail overTimeDetailAlias = null;
Department departmentAlias = null;
IQueryOver <OverTimeDetail, OverTimeDetail> searchQuery;
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
searchQuery = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.Where(() =>
departmentAlias.ID.IsIn(accessableIDs.ToList()) &&
overTimeAlias.Date == Date &&
departmentAlias.ParentPath.IsLike("," + parentDepartmentId + ",", MatchMode.Anywhere) &&
departmentAlias.DepartmentType == DepartmentType.Assistance &&
overTimeAlias.IsActive == true);
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
searchQuery = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() =>
tempAlias.OperationGUID == operationGUID &&
overTimeAlias.Date == Date &&
departmentAlias.ParentPath.IsLike("," + parentDepartmentId + ",", MatchMode.Anywhere) &&
departmentAlias.DepartmentType == DepartmentType.Assistance &&
overTimeAlias.IsActive == true);
this.bTemp.DeleteTempList(operationGUID);
}
if (!Utility.IsEmpty(departmentName))
{
searchQuery.Where(() => departmentAlias.Name.IsLike(departmentName, MatchMode.Anywhere));
}
count = searchQuery.RowCount();
IList <OverTimeDetail> list = new List <OverTimeDetail>();
list = searchQuery.Skip(pageIndex * pageSize).Take(pageSize).List <OverTimeDetail>();
personList = bPerson.GetPersonsInfoForOverTime();
IList <OverTimeProxy> proxyList = new List <OverTimeProxy>();
var calendarList = bCalendar.GetCalendarListByDateRange(Date, Date.AddMonths(1), "6");
foreach (var item in list)
{
OverTimeProxy proxy = ConvertToProxy(item);
proxy.MonthHolidayCount = calendarList != null?calendarList.Count() : 0;
proxyList.Add(proxy);
}
return(proxyList);
}
