private void UpdateChildDepartments(XStorageConnection con, DomainObjectDataSet dataSet, Guid objectID, bool IsArchive)
{
// Обновляем вложенные департаменты, если мы меняем признак на "Архивный".
// Если признак "Архивный" снимается, каскадной разархивации не происходит.
// зачитаем идентификаторы всех подчиненных департаментов, состояние которых отличается от требуемого
if (IsArchive)
{
XDbCommand cmd = con.CreateCommand(@"
SELECT d.ObjectID
FROM dbo.Department as d_s WITH(NOLOCK)
JOIN dbo.Department as d WITH(NOLOCK) ON d.LIndex > d_s.LIndex AND d.RIndex < d_s.RIndex AND d.Organization = d_s.Organization
WHERE d_s.ObjectID = @ObjectID AND d.IsArchive <> @IsArchive
" );
cmd.Parameters.Add("ObjectID", DbType.Guid, ParameterDirection.Input, false, objectID);
cmd.Parameters.Add("IsArchive", DbType.Boolean, ParameterDirection.Input, false, IsArchive);
using (IDataReader reader = cmd.ExecuteReader())
{
DomainObjectData xobjSubDepartment;
while (reader.Read())
{
xobjSubDepartment = dataSet.GetLoadedStub("Department", reader.GetGuid(0));
xobjSubDepartment.SetUpdatedPropValue("IsArchive", IsArchive);
}
}
}
}
public void ExecuteTrigger(DomainObjectDataSet dataSet, DomainObjectData xobj, IXExecutionContext context)
{
XTrigger trigger = (XTrigger)m_factory.GetInstance();
XTriggerArgs args = new XTriggerArgs(m_action, m_fireTime, m_fireType, dataSet, xobj);
trigger.Execute(args, context);
}
public override XTreeMenuInfo GetMenu(XGetTreeMenuRequest request, IXExecutionContext context, XTreePageInfoStd treePage)
{
XTreeStructInfo treeStructInfo = treePage.TreeStruct;
XTreeLevelInfoIT levelinfo = treeStructInfo.Executor.GetTreeLevel(treeStructInfo, request.Params, request.Path);
XTreeMenuInfo treemenu = null;
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
Guid ObjectID = request.Path[0].ObjectID;
switch (levelinfo.ObjectType)
{
case "IncidentCategory":
treemenu = getMenuForIncidentCategory(ObjectID, dataSet, context);
break;
default:
treemenu = levelinfo.GetMenu(request, context);
break;
}
if (treemenu == null)
{
treemenu = treePage.DefaultLevelMenu.GetMenu(levelinfo, request, context);
}
if (treemenu != null)
{
if (context.Config.IsDebugMode)
{
treemenu.Items.AddActionItem("ќбновить", StdActions.DoNodeRefresh).SeparatorBefore = true;
}
}
return(treemenu);
}
/// <summary>
/// Выполнение команды - типизированный вариант
/// </summary>
/// <param name="request">Запрос команды, должен иметь тип XGetPropertyRequest</param>
/// <param name="context">Контекст выполнения команды</param>
/// <returns>XGetPropertyResponse</returns>
public new XGetPropertyResponse Execute(XGetPropertyRequest request, IXExecutionContext context)
{
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
// создадим болванку объекта
DomainObjectData xobj = dataSet.GetLoadedStub(request.TypeName, request.ObjectID);
// загрузим свойства
dataSet.LoadProperty(context.Connection, xobj, request.PropName);
// создадим форматировщик
DomainObjectDataXmlFormatter formatter = new DomainObjectDataXmlFormatter(context.Connection.MetadataManager);
// и сериализуем свойство в XML
XmlElement xmlProperty = formatter.SerializeProperty(xobj, request.PropName);
// по всем объектам в свойстве (LoadProperty вызывается не только для объектных свойств - еще для bin и text)
// обработаем объект и все вложенные объекты в прогруженных свойства, расставим атрибуты ограничения доступа
foreach (XmlElement xmlObject in xmlProperty.SelectNodes("*[*]"))
{
DomainObjectData xobjValue = xobj.Context.Find(xmlObject.LocalName, new Guid(xmlObject.GetAttribute("oid")));
if (xobjValue == null)
{
throw new ApplicationException("Не удалось найти в контексте типизированного объекта DomainObjectData для xml-объекта-значения свойства " + xmlProperty.LocalName + " объекта " + xmlObject.LocalName);
}
XmlObjectRightsProcessor.ProcessObject(xobjValue, xmlObject);
}
XGetPropertyResponse response = new XGetPropertyResponse(xmlProperty);
return(response);
}
private DomainObjectData loadFolderAndIncident(DomainObjectDataSet dataSet, GetMailMsgInfoRequest request, IXExecutionContext context)
{
DomainObjectData xobjFolder;
if (request.ObjectType == "Folder")
{
xobjFolder = dataSet.GetLoadedStub("Folder", request.ObjectID);
dataSet.LoadProperty(context.Connection, xobjFolder, "Name");
}
else
{
XDbCommand cmd = context.Connection.CreateCommand(
@"SELECT f.ObjectID as FolderID, f.Name as FolderName, i.Name as IncidentName, i.Number as IncidentNumber
FROM Incident i JOIN Folder f ON i.Folder=f.ObjectID
WHERE i.ObjectID = @IncidentID" );
cmd.Parameters.Add("IncidentID", DbType.Guid, ParameterDirection.Input, false, request.ObjectID);
DomainObjectData xobjIncident = dataSet.GetLoadedStub("Incident", request.ObjectID);
using (IDataReader reader = cmd.ExecuteReader())
{
if (!reader.Read())
{
throw new XObjectNotFoundException("Incident", request.ObjectID);
}
xobjFolder = dataSet.GetLoadedStub("Folder", reader.GetGuid(reader.GetOrdinal("FolderID")));
xobjFolder.SetLoadedPropValue("Name", reader.GetString(reader.GetOrdinal("FolderName")));
xobjIncident.SetLoadedPropValue("Name", reader.GetString(reader.GetOrdinal("IncidentName")));
xobjIncident.SetLoadedPropValue("Number", reader.GetInt32(reader.GetOrdinal("IncidentNumber")));
xobjIncident.SetLoadedPropValue("Folder", xobjFolder.ObjectID);
}
}
return(xobjFolder);
}
public GetObjectsRightsExResponse Execute(CheckDatagramRequest request, IXExecutionContext context)
{
XObjectRightsDescr[] objectPermissionCheckList = new XObjectRightsDescr[request.ObjectsToCheck.Length];
DomainObjectDataXmlFormatter formatter = new DomainObjectDataXmlFormatter(context.Connection.MetadataManager);
DomainObjectDataSet dataSet = formatter.DeserializeForSave(request.XmlDatagram);
int nIndex = -1;
foreach (XObjectIdentity obj_id in request.ObjectsToCheck)
{
DomainObjectData xobj = dataSet.Find(obj_id.ObjectType, obj_id.ObjectID);
//if (xobj.IsNew && xobj == null)
// throw new ArgumentException("Датаграмма не содержит нового объекта, для которого требуется вычислить права: " +obj_id.ObjectType + "[" + obj_id.ObjectType + "]");
if (xobj == null)
{
xobj = dataSet.Load(context.Connection, obj_id.ObjectType, obj_id.ObjectID);
}
if (xobj.IsNew)
{
objectPermissionCheckList[++nIndex] = createObjectRightsDescr(XSecurityManager.Instance.GetRightsOnNewObject(xobj));
}
else
{
objectPermissionCheckList[++nIndex] = createObjectRightsDescr(XSecurityManager.Instance.GetObjectRights(xobj));
}
}
// Формируем результат операции
return(new GetObjectsRightsExResponse(objectPermissionCheckList));
}
/// <summary>
/// Сохранение данных множества объектов.
/// </summary>
/// <remarks>
/// Управление транзакцией внешнее.
/// </remarks>
/// <param name="context"></param>
/// <param name="dataSet"></param>
/// <param name="transactionID"></param>
public static void Save(IXExecutionContext context, DomainObjectDataSet dataSet, Guid transactionID)
{
// #1: Вызов триггеров Before
XTriggersController.Instance.FireTriggers(dataSet, XTriggerFireTimes.Before, context);
// #2: Сбросим закэшированные данные объектов
IEnumerator enumerator = dataSet.GetModifiedObjectsEnumerator(false);
while (enumerator.MoveNext())
{
DomainObjectData xobj = (DomainObjectData)enumerator.Current;
// Примечание: для новых объектов сбрасывать кэш бессмысленно - их там нет
if (!xobj.IsNew)
{
DomainObjectRegistry.ResetObject(xobj);
}
}
// #3: Запись данных
XDatagramProcessorEx dg_proc = XDatagramProcessorMsSqlEx.Instance;
XDatagramBuilder dgBuilder = dg_proc.GetDatagramBuilder();
XDatagram dg = dgBuilder.GetDatagram(dataSet);
dg_proc.Save(context.Connection, dg);
// #4: Сохранение chunked-данных
saveChunkedData(transactionID, dg, context.Connection);
// #5: Сигнализируем Securitymanager, что обновились данные (для очистки кэшей)
XSecurityManager.Instance.TrackModifiedObjects(dataSet);
// #6: Вызов триггеров After
XTriggersController.Instance.FireTriggers(dataSet, XTriggerFireTimes.After, context);
}
public XTriggerArgs(XTriggerActions action, XTriggerFireTimes fireTimes, XTriggerFireTypes eventType, DomainObjectDataSet dataSet, DomainObjectData xobj)
{
m_action = action;
m_fireTime = fireTimes;
m_fireType = eventType;
m_dataSet = dataSet;
m_xobj = xobj;
}
public DomainObjectDataSet DeserializeForSave(XmlElement xmlDatagram)
{
DomainObjectDataSet dataSet = new DomainObjectDataSet(m_mdManager.XModel);
parseXmlForest(xmlDatagram, dataSet);
checkAndSyncReverseProps(dataSet);
return(dataSet);
}
/// <summary>
/// Операция получения XML-документа с данными набора заданных ds-объектов
/// ТИПИЗИРОВАННАЯ ВЕРСИЯ МЕТОДА
/// АВТОМАТИЧЕСКИ ВЫЗЫВАЕТСЯ ЯДРОМ
/// </summary>
/// <param name="request">Запрос на вполнение операции</param>
/// <param name="context">Контекст выоленения операции</param>
/// <returns>Результат выполенения операции</returns>
public XGetObjectsResponse Execute(XGetObjectsRequest request, IXExecutionContext context)
{
// Проверка праметров - массив с перечнем идентификационных данных
// объектов должен быть задан, и не должен быть пустым:
if (null == request.List)
{
throw new ArgumentNullException("request.List");
}
if (0 == request.List.Length)
{
throw new ArgumentException("request.List");
}
XmlDocument xmlDoc = new XmlDocument();
XmlElement xmlRootElement = xmlDoc.CreateElement("root");
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
DomainObjectDataXmlFormatter formatter = new DomainObjectDataXmlFormatter(context.Connection.MetadataManager);
DomainObjectData xobj;
foreach (XObjectIdentity i in request.List)
{
if (i.ObjectID == Guid.Empty)
{
xmlRootElement.AppendChild(context.Connection.Create(i.ObjectType, xmlDoc));
}
else
{
try
{
xobj = dataSet.Load(context.Connection, i.ObjectType, i.ObjectID);
xmlRootElement.AppendChild(formatter.SerializeObject(xobj, xmlDoc));
}
catch (XObjectNotFoundException)
{
XmlElement xmlStub = (XmlElement)xmlRootElement.AppendChild(
context.Connection.CreateStub(i.ObjectType, i.ObjectID, xmlDoc));
xmlStub.SetAttribute("not-found", "1");
}
}
}
// по всем запрошенным объектам
foreach (XmlElement xmlObject in xmlRootElement.SelectNodes("*[*]"))
{
// обработаем объект и все вложенные объекты в прогруженных свойства, расставим атрибуты ограничения доступа
if (!xmlObject.HasAttribute("new"))
{
DomainObjectData xobjValue = dataSet.Find(xmlObject.LocalName, new Guid(xmlObject.GetAttribute("oid")));
if (xobjValue == null)
{
throw new ApplicationException("Не удалось найти в контексте типизированного объекта DomainObjectData для xml объекта: " + xmlObject.OuterXml);
}
XmlObjectRightsProcessor.ProcessObject(xobjValue, xmlObject);
}
}
return(new XGetObjectsResponse(xmlRootElement));
}
/// <summary>
/// Возвращает массив наименований пользователей приложения,
/// кэш описаний которых следует сбросить из-за изменений объектов в переданном (полученном от клиента) множестве
/// </summary>
/// <param name="dataSet">Множество модифицированных объектов</param>
/// <param name="users">Коллекция (кэш) описаний пользователей приложения (ITUser)</param>
/// <returns>массив наименований пользователей, описание которых надо сбросить</returns>
public string[] GetAffectedUserNames(DomainObjectDataSet dataSet, ICollection users)
{
string[] affectedUserNames = null;
ArrayList affectedUserNamesList = null;
bool bFlushAllUsers = false; // признак "сбросить описания всех пользователей"
foreach (DomainObjectData xobj in dataSet.GetModifiedObjectsByType(new string[] { "SystemUser", "Employee", "ActivityType", "Organization" }, true))
{
// при изменении типов проектных затрат сбросим описание всех пользователей
if (xobj.ObjectType == "ActivityType")
{
bFlushAllUsers = true;
}
else if (xobj.ObjectType == "Organization")
{
bFlushAllUsers = true;
}
else if (xobj.ObjectType == "SystemUser" || xobj.ObjectType == "Employee")
{
foreach (ITUser user in users)
{
if (user.SystemUserID == xobj.ObjectID && xobj.ObjectType == "SystemUser" ||
user.EmployeeID == xobj.ObjectID && xobj.ObjectType == "Employee"
)
{
if (affectedUserNamesList == null)
{
affectedUserNamesList = new ArrayList();
}
affectedUserNamesList.Add(user.Name);
break;
}
}
}
if (bFlushAllUsers)
{
if (affectedUserNamesList == null)
{
affectedUserNamesList = new ArrayList();
}
else
{
affectedUserNamesList.Clear();
}
affectedUserNamesList.Add(XSecurityManager.USERNAME_ALLUSERS);
break;
}
}
if (affectedUserNamesList != null)
{
affectedUserNames = new string[affectedUserNamesList.Count];
affectedUserNamesList.CopyTo(affectedUserNames);
}
return(affectedUserNames);
}
protected DomainObjectData getFolderHistoryObject(DomainObjectDataSet dataSet, DomainObjectData xobjFolder)
{
DomainObjectData xobjHistory = dataSet.CreateNew("FolderHistory", true);
xobjHistory.SetUpdatedPropValue("Folder", xobjFolder.ObjectID);
ITUser user = (ITUser)XSecurityManager.Instance.GetCurrentUser();
xobjHistory.SetUpdatedPropValue("SystemUser", user.SystemUserID);
xobjHistory.SetUpdatedPropValue("EventDate", DateTime.Now);
return(xobjHistory);
}
/// <summary>
/// ћетод запуска операции на выполнение, Ђвходна¤ї точка операции
/// </summary>
/// <param name="request">«апрос на выполнение операции</param>
/// <param name="context"> онтекст выполнени¤ операции</param>
/// <returns>–езультат выполнени¤</returns>
/// <remarks>
/// -- ѕ≈–≈√–”∆≈ЌЌџ…, —“–ќ√ќ “»ѕ»«»–ќ¬јЌЌџ… ћ≈“ќƒ, ¬џ«џ¬ј≈“—я яƒ–ќћ
/// -- ѕроверка параметров запроса реализована в методе Validate запроса,
/// который автоматически вызываетс¤ ядром при получении запроса
/// </remarks>
public XGetObjectsRightsResponse Execute(XGetObjectsRightsRequest request, IXExecutionContext context)
{
Boolean[] objectPermissionCheckList = new Boolean[request.Permissions.Length];
IDictionary checkedObjects = new HybridDictionary();
IDictionary checkedTypes = new Hashtable();
XObjectRights rights;
int nIndex = -1;
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
foreach (XObjectPermission permission in request.Permissions)
{
bool bHasRight = true;
if ((permission.Action & XObjectActionEnum.Create) == XObjectActionEnum.Create)
{
if (checkedTypes.Contains(permission.TypeName))
{
bHasRight = (bool)checkedTypes[permission.TypeName];
}
else
{
bHasRight = XSecurityManager.Instance.GetRightsOnNewObject(
dataSet.CreateStubNew(permission.TypeName)
).AllowCreate;
checkedTypes[permission.TypeName] = bHasRight;
}
}
if (bHasRight && (
((permission.Action & XObjectActionEnum.Change) > 0) ||
((permission.Action & XObjectActionEnum.Delete) > 0) ||
((permission.Action & XObjectActionEnum.Read) > 0)
))
{
rights = (XObjectRights)checkedObjects[permission.TypeName + ":" + permission.ObjectID];
if (rights == null)
{
rights = XSecurityManager.Instance.GetObjectRights(
dataSet.GetLoadedStub(permission.TypeName, permission.ObjectID)
);
checkedObjects[permission.TypeName + ":" + permission.ObjectID] = rights;
}
bHasRight = ((permission.Action & XObjectActionEnum.Change) > 0) && rights.AllowParticalOrFullChange ||
((permission.Action & XObjectActionEnum.Delete) > 0) && rights.AllowDelete ||
((permission.Action & XObjectActionEnum.Read) > 0) && rights.AllowParticalOrFullRead;
}
// «аписываем полученный флаг в результирующий массив
objectPermissionCheckList[++nIndex] = bHasRight;
}
// ‘ормируем результат операции
return(new XGetObjectsRightsResponse(objectPermissionCheckList));
}
public XDatagram GetDatagram(DomainObjectDataSet dataSet)
{
XDatagram dg = new XDatagram();
IEnumerator enumerator = dataSet.GetModifiedObjectsEnumerator(false);
while (enumerator.MoveNext())
{
XStorageObjectBase xobj = createXStorageObject((DomainObjectData)enumerator.Current);
add(xobj);
createObjectsFromLinks(xobj);
}
fillDatagram(dg);
return(dg);
}
public override XTreeMenuInfo GetMenuForEmptyTree(XGetTreeMenuRequest request, IXExecutionContext context, XTreePageInfoStd treePage)
{
XTreeMenuInfo menu = new XTreeMenuInfo("", true);
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
DomainObjectData xobj = dataSet.CreateNew("IncidentType", true);
XNewObjectRights create_right = XSecurityManager.Instance.GetRightsOnNewObject(xobj);
if (create_right.AllowCreate)
{
XMenuActionItem item = menu.Items.AddActionItem("—оздать тип инцидента", StdActions.DoCreate);
item.Parameters.Add("ObjectType", "IncidentType");
}
return(menu);
}
private XTreeMenuInfo getMenuForEmployee(Guid ObjectID, DomainObjectDataSet dataSet, IXExecutionContext context)
{
XTreeMenuInfo menu = new XTreeMenuInfo("@@Title", true);
menu.CacheMode = XTreeMenuCacheMode.NoCache;
menu.ExecutionHandlers.Add(new XUserCodeWeb("CompanyTree_Menu_ExecutionHandler"));
// просмотр
// Раскоментировать после удаления ссылок на НСИ
//menu.Items.AddActionItem("Просмотр", StdActions.DoView).Parameters.Add("ReportURL", StdMenuUtils.GetEmployeeReportURL(context.Config, ObjectID));
DomainObjectData xobj = dataSet.GetLoadedStub("Employee", ObjectID);
XObjectRights rights = XSecurityManager.Instance.GetObjectRights(xobj);
// Редактировать
if (rights.AllowParticalOrFullChange)
{
menu.Items.AddActionItem("Редактировать", StdActions.DoEdit).Default = true;
}
// Удалить
if (rights.AllowDelete)
{
menu.Items.AddActionItem("Удалить", StdActions.DoDelete);
}
// Секция "Отчеты"
//XMenuActionItem item;
//XMenuSection sec = menu.Items.AddSection("Отчеты");
//item = sec.Items.AddActionItem("Сальдо ДС", "DoView");
//item.Parameters.Add("ReportURL", "x-get-report.aspx?name=r-EmployeeSaldoDS.xml&EmployeeID=@@ObjectID");
/*
* item = sec.Items.AddActionItem("Инциденты и списания времени сотрудника", "DoRunReport");
* item.Parameters.Add("ReportName", "ReportEmployeeExpensesList");
* item.Parameters.Add("UrlParams", ".Employee=" + ObjectID);
* item = sec.Items.AddActionItem("Баланс списаний сотрудника", "DoRunReport");
* item.Parameters.Add("ReportName", "EmployeeExpensesBalance");
* item.Parameters.Add("UrlParams", ".Employee=" + ObjectID);
* item = sec.Items.AddActionItem("Плановая занятость сотрудников", "DoRunReport");
* item.Parameters.Add("ReportName", "Employment");
* item.Parameters.Add("UrlParams", ".Employees=" + ObjectID + "&.Organizations=&.Departments=");
*/
// Секция "Информация"
XMenuSection sec = menu.Items.AddSection("Информация");
fillEmployeeInfoSection(sec, ObjectID, context.Connection);
return(menu);
}
public XResponse Execute(MoveObjectsRequest request, IXExecutionContext context)
{
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
foreach (Guid oid in request.SelectedObjectsID)
{
DomainObjectData xobj = dataSet.CreateStubLoaded(request.SelectedObjectType, oid, -1);
xobj.SetUpdatedPropValue(request.ParentPropName, request.NewParent);
// для объекта проверим права
XSecurityManager.Instance.DemandSaveObjectPrivilege(xobj);
}
XStorageGateway.Save(context, dataSet, Guid.NewGuid());
return(new XResponse());
}
/// <summary>
/// Уведомление со стороны XSecurityManager'a об изменившихся объектах
/// </summary>
/// <param name="dataSet">Сохраняемое множество объектов</param>
public void TrackModifiedObjects(DomainObjectDataSet dataSet)
{
IEnumerator enumerator = dataSet.GetModifiedObjectsEnumerator(false);
while (enumerator.MoveNext())
{
DomainObjectData xobj = (DomainObjectData)enumerator.Current;
if (xobj.ObjectType == "ProjectParticipant" || xobj.ObjectType == "UserRoleInProject")
{
FolderPrivilegesDefinitionContainer container = (FolderPrivilegesDefinitionContainer)ObjectPrivilegeContainers["Folder"];
container.FlushCache();
break;
}
}
}
/// <summary>
/// Параметр делегата CreateCacheValue - вызывает при отсутствии запрощенного объекта в кэше
/// </summary>
/// <param name="key">ключ в кэше - реализация IXObjectIdentity (XObjectIdentity или наследники XObjectBase)</param>
/// <param name="param">экземпляр XStorageConnection</param>
/// <returns>Данные запрошенного объекта - экземпляр DomainObjectData</returns>
private static object loadObject(object key, object param)
{
Debug.Assert(key != null);
Debug.Assert(param != null);
if (param == null)
{
throw new ArgumentNullException("param");
}
IXObjectIdentity obj_id = (IXObjectIdentity)key;
XStorageConnection con = (XStorageConnection)param;
DomainObjectDataSet dataSet = new DomainObjectDataSet(con.MetadataManager.XModel);
return(dataSet.Load(con, obj_id.ObjectType, obj_id.ObjectID));
}
/// <summary>
/// Рекурсивно обходит xml-дерево и разбирает на отдельные объекты.
/// Каждый объект добавляется во множество методом Add.
/// </summary>
/// <param name="xmlRoot">лес xml-объектов, скрепленный тегом x-datagram, либо одиночный объект</param>
private void parseXmlForest(XmlElement xmlRoot, DomainObjectDataSet dataSet)
{
// сформируем множество объектов подлежащих вставке, обновлению и удалению
if (xmlRoot.LocalName == "x-datagram")
{
foreach (XmlElement xmlObject in xmlRoot.SelectNodes("*"))
{
walkThroughXmlObjects(xmlObject, dataSet, true);
}
}
else
{
// на корневом уровне не x-datagram, считаем, что это одиночный объект
walkThroughXmlObjects(xmlRoot, dataSet, true);
}
}
public override XTreeMenuInfo GetMenuForEmptyTree(XGetTreeMenuRequest request, IXExecutionContext context, XTreePageInfoStd treePage)
{
XTreeMenuInfo menu = new XTreeMenuInfo("", true);
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
DomainObjectData xobj = dataSet.CreateNew("Organization", true);
xobj.SetUpdatedPropValue("Home", true);
XNewObjectRights create_right = XSecurityManager.Instance.GetRightsOnNewObject(xobj);
if (create_right.AllowCreate)
{
XMenuActionItem item = menu.Items.AddActionItem("Создать организацию-владельца системы", StdActions.DoCreate);
item.Parameters.Add("ObjectType", "Organization");
item.Parameters.Add("URLPARAMS", ".Home=1");
}
return(menu);
}
public override XTreeMenuInfo GetMenu(XGetTreeMenuRequest request, IXExecutionContext context, XTreePageInfoStd treePage)
{
XTreeStructInfo treeStructInfo = treePage.TreeStruct;
XTreeLevelInfoIT levelinfo = treeStructInfo.Executor.GetTreeLevel(treeStructInfo, request.Params, request.Path);
XTreeMenuInfo treemenu = null;
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
// получим идентификатор объекта, для которого строится меню
Guid ObjectID = request.Path.PathNodes[0].ObjectID;
switch (levelinfo.ObjectType)
{
case "Organization":
treemenu = getMenuForOrganization(ObjectID, dataSet, context);
break;
case "Department":
treemenu = getMenuForDepartment(ObjectID, dataSet, context);
break;
case "Employee":
treemenu = getMenuForEmployee(ObjectID, dataSet, context);
break;
default:
treemenu = levelinfo.GetMenu(request, context);
break;
}
if (treemenu == null)
{
treemenu = treePage.DefaultLevelMenu.GetMenu(levelinfo, request, context);
}
if (treemenu != null)
{
if (context.Config.IsDebugMode)
{
treemenu.Items.AddActionItem("Обновить", StdActions.DoNodeRefresh).SeparatorBefore = true;
}
}
return(treemenu);
}
/// <summary>
/// Выполнение команды - типизированный вариант
/// </summary>
/// <param name="request">Запрос команды, должен иметь тип XGetPropertyRequest</param>
/// <param name="context">Контекст выполнения команды</param>
public XGetObjectResponse Execute(XGetObjectRequest request, IXExecutionContext context)
{
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
DomainObjectData xobj;
if (request.ObjectID != Guid.Empty)
{
xobj = dataSet.Load(context.Connection, request.TypeName, request.ObjectID);
// Если заданы цепочки прогружаемых свойств, загрузим и эти данные:
if (request.PreloadProperties != null)
{
// ...По каждому списку прогружаемых свойств
foreach (string sPropList in request.PreloadProperties)
{
// Проверяем, что в массиве не передали null и пустые строки
if (null == sPropList)
{
throw new ArgumentNullException("PreloadProperties");
}
if (String.Empty == sPropList)
{
throw new ArgumentException(ERR_EMPTY_PRELOAD_PATH, "PreloadProperties");
}
dataSet.PreloadProperty(context.Connection, xobj, sPropList);
}
}
}
else
{
xobj = dataSet.CreateNew(request.TypeName, false);
}
// сериализуем датасет с загруженными объектами в формат для Web-клиента
DomainObjectDataXmlFormatter formatter = new DomainObjectDataXmlFormatter(context.Connection.MetadataManager);
XmlElement xmlObject = formatter.SerializeObject(xobj, request.PreloadProperties);
if (request.ObjectID != Guid.Empty)
{
// ..обработаем объект и все вложенные объекты в прогруженных свойства, расставим атрибуты ограничения доступа
XmlObjectRightsProcessor.ProcessObject(xobj, xmlObject);
}
return(new XGetObjectResponse(xmlObject));
}
public SaveObjectInternalRequest(XSaveObjectRequest originalRequest, IXExecutionContextService context)
: base(DEF_COMMAND_NAME)
{
m_originalRequest = originalRequest;
// установим идентификатор транзакции
if (originalRequest.XmlSaveData.HasAttribute("transaction-id"))
{
m_TransactionID = new Guid(originalRequest.XmlSaveData.GetAttribute("transaction-id"));
}
else
{
m_TransactionID = Guid.NewGuid();
}
DomainObjectDataXmlFormatter formatter = new DomainObjectDataXmlFormatter(context.Connection.MetadataManager);
m_dataSet = formatter.DeserializeForSave(originalRequest.XmlSaveData);
}
/// <summary>
/// Создает объект "Списание времение" на основании шаблона
/// </summary>
private DomainObjectData createTimeLossObject(DomainObjectDataSet dataSet, DomainObjectData template, ITUser user)
{
DomainObjectData xobj = dataSet.CreateStubNew("TimeLoss");
xobj.SetUpdatedPropValue("Cause", template.GetUpdatedPropValue("Cause"));
if (template.HasUpdatedProp("Worker"))
{
xobj.SetUpdatedPropValue("Worker", template.GetUpdatedPropValue("Worker"));
}
else
{
xobj.SetUpdatedPropValue("Worker", user.EmployeeID);
}
if (template.HasUpdatedProp("Folder"))
{
xobj.SetUpdatedPropValue("Folder", template.GetUpdatedPropValue("Folder"));
}
return(xobj);
}
public virtual void TrackModifiedObjects(DomainObjectDataSet dataSet)
{
string[] userNames = m_SecurityProvider.GetAffectedUserNames(dataSet, m_AuthenticatedUsers.Values);
if (userNames != null && userNames.Length > 0)
{
foreach (string sUserName in userNames)
{
if (sUserName == USERNAME_ALLUSERS)
{
FlushAllUsers();
break;
}
else
{
FlushUser(sUserName);
}
}
}
m_SecurityProvider.TrackModifiedObjects(dataSet);
}
/// <summary>
/// Получение меню в runtime для уровня (treeLevelInfo задан) или пустой иерархии (treeLevelInfo равен null)
/// </summary>
/// <param name="treeLevelInfo">описание уровня, для которого запрашивается меню, или null</param>
/// <param name="request">параметры с клиента</param>
/// <returns></returns>
public XTreeMenuInfo GetMenu(XTreeLevelInfoIT treeLevelInfo, XGetTreeMenuRequest request, IXExecutionContext context)
{
DomainObjectDataSet dataSet = new DomainObjectDataSet(context.Connection.MetadataManager.XModel);
DomainObjectData xobj = dataSet.GetLoadedStub(request.Path.PathNodes[0].ObjectType, request.Path.PathNodes[0].ObjectID);
XTreeMenuInfo menu = new XTreeMenuInfo("@@Title", true);
menu.CacheMode = XTreeMenuCacheMode.NoCache;
XMenuActionItem item;
XObjectRights rights = XSecurityManager.Instance.GetObjectRights(xobj);
if (rights.AllowParticalOrFullChange)
{
item = menu.Items.AddActionItem("Редактировать", StdActions.DoEdit);
item.Hotkey = "VK_ENTER";
item.Parameters.Add("RefreshFlags", "TRM_NODE+TRM_PARENTNODE");
}
XNewObjectRights create_rights = XSecurityManager.Instance.GetRightsOnNewObject(dataSet.CreateNew(xobj.ObjectType, true));
if (create_rights.AllowCreate)
{
item = menu.Items.AddActionItem("Создать", StdActions.DoCreate);
item.Hotkey = "VK_INS";
item.Parameters.Add("RefreshFlags", "TRM_TREE");
if (rights.AllowDelete)
{
menu.Items.AddSeparatorItem();
}
}
if (rights.AllowDelete)
{
item = menu.Items.AddActionItem("Удалить", StdActions.DoDelete);
item.Hotkey = "VK_DEL";
item.Parameters.Add("RefreshFlags", "TRM_TREE");
}
return(menu);
}
public void FireTriggers(DomainObjectDataSet dataSet, XTriggerFireTimes fireTime, IXExecutionContext context)
{
if (m_triggersForObjects.Length == 0 && m_triggersForGroups.Length == 0 && m_triggersForWholeDataSet.Length == 0)
{
return;
}
if (m_triggersForObjects.Length + m_triggersForGroups.Length > 0)
{
IEnumerator enumerator = dataSet.GetModifiedObjectsEnumerator(false);
while (enumerator.MoveNext())
{
DomainObjectData xobj = (DomainObjectData)enumerator.Current;
fireTriggersForObject(xobj, fireTime, context);
}
}
if (m_triggersForWholeDataSet.Length > 0)
{
foreach (XTriggerDescription trigger in m_triggersForWholeDataSet)
{
trigger.ExecuteTrigger(dataSet, null, context);
}
}
}
/// <summary>
/// Добавляет значение в объектное свойство.
/// Если объект-значение присутствует в контексте, то запускаем его сериализацию (serializeObject), иначе создаем болванку (тип+идентификатор)
/// </summary>
/// <param name="dataSet"></param>
/// <param name="xmlProp">Текущее объектное свойство (скалярное или массивное)</param>
/// <param name="propInfo">Метаданные свойства</param>
/// <param name="valueOID">Идентификатор объекта-значения</param>
private void addValueIntoObjectProp(DomainObjectDataSet dataSet, XmlElement xmlProp, XPropInfoObject propInfo, Guid valueOID, PreloadsNavigator nav)
{
XmlElement xmlObjectValue; // xml-представление объект-значение
DomainObjectData xobjValue = null; // объект-значение свойства в контексте
// теоретически контекста может не быть
if (dataSet != null && nav != null)
{
xobjValue = dataSet.Find(propInfo.ReferedType.Name, valueOID);
}
if (xobjValue != null && nav != null)
{
// Объект-значение свойства загружен в контекст и задан навигатор - запустим рекурсивно его сериализацию
xmlObjectValue = serializeObject(xobjValue, xmlProp.OwnerDocument, nav);
}
else
{
xmlObjectValue = xmlProp.OwnerDocument.CreateElement(propInfo.ReferedType.Name);
xmlObjectValue.SetAttribute("oid", valueOID.ToString());
}
// добавим объект-значение (буть-то ссылка или полный объект)
xmlProp.AppendChild(xmlObjectValue);
}
/// <summary>
/// ¬нутренний метод получени¤ данных объекта UserProfile дл¤ пользовател¤
/// системы, заданного идентификатором (SystemUser.ObjectID).
/// </summary>
/// <param name="uidSystemUserID">»дентификатор пользовател¤</param>
/// <returns>
/// -- »нифиализированный объект DomainObjectData, описывающий данные UserProfile
/// -- null, если профил¤ пользовател¤ нет (что, в принципе возможно)
/// </returns>
protected DomainObjectData getUserProfile(Guid uidSystemUserID, XStorageConnection connection)
{
// ѕолучим идентификатор объекта UserProfile, соответствующего
// указанному пользователю; дл¤ этого воспользуемс¤ запросом,
// "зашитым" в data-source:
// ...параметр запроса - идентификатор пользовател¤:
XParamsCollection datasourceParams = new XParamsCollection();
datasourceParams.Add("UserID", uidSystemUserID);
// ...получение и выполнение источника данных:
XDataSource dataSource = connection.GetDataSource(DEF_DATASOURCE_NAME);
dataSource.SubstituteNamedParams(datasourceParams, true);
dataSource.SubstituteOrderBy();
object oResult = dataSource.ExecuteScalar();
// ќжидаетс¤, что в результате мы получаем GUID: если в результате
// получили null - что говорит об отсутствии профил¤ - возвращаем null:
Guid uidResult = Guid.Empty;
if (null != oResult && DBNull.Value != oResult)
{
uidResult = connection.Behavior.CastGuidValueFromDB(oResult);
}
if (Guid.Empty == uidResult)
{
return(null);
}
// «агрузка данных профил¤ пользовател¤:
DomainObjectDataSet dataSet = new DomainObjectDataSet(connection.MetadataManager.XModel);
DomainObjectData xobj = dataSet.Load(connection, "UserProfile", uidResult);
return(xobj);
}
