private void CreateReminding(ImportParameters parameters)
{
Guid contactId = parameters.AuthorId;
DateTime dateTime = TimeZoneInfo.ConvertTimeFromUtc(new DateTimeProvider().UtcNow, parameters.AuthorTimeZone);
uint notImportedRowsCount = parameters.NotImportedRowsCount;
string description = string.Format(CompleteRemindingDescriptionTemplate, parameters.ImportedRowsCount,
parameters.TotalRowsCount, parameters.FileName);
if (notImportedRowsCount > 0)
{
description += string.Format(NotImportedRowsCountMessageTemplate, notImportedRowsCount);
}
string caption = string.Format("{0} {1}", CompleteRemindingSubject, description);
ISchemaManagerItem <EntitySchema> importSessionItem =
UserConnection.EntitySchemaManager.GetItemByName("ImportSession");
ISchemaManagerItem <EntitySchema> sysProcessLogItem =
UserConnection.EntitySchemaManager.GetItemByName("VwSysProcessLog");
EntitySchema remindingSchema = UserConnection.EntitySchemaManager.GetInstanceByName("Reminding");
Entity reminding = remindingSchema.CreateEntity(UserConnection);
reminding.SetDefColumnValues();
reminding.SetColumnValue("AuthorId", contactId);
reminding.SetColumnValue("ContactId", contactId);
reminding.SetColumnValue("SourceId", RemindingConsts.RemindingSourceAuthorId);
reminding.SetColumnValue("RemindTime", dateTime);
reminding.SetColumnValue("Description", description);
reminding.SetColumnValue("SubjectId", parameters.ImportSessionId);
reminding.SetColumnValue("SysEntitySchemaId", sysProcessLogItem.UId);
reminding.SetColumnValue("SubjectCaption", caption);
reminding.SetColumnValue("LoaderId", importSessionItem.UId);
reminding.Save();
}
/// <summary>
/// When <paramref name="item"/> is not null, adds <paramref name="item"/> unique identifier to <paramref name="list"/>.
/// </summary>
/// <param name="list"><see cref="List{Guid}"/> instance.</param>
/// <param name="item"><see cref="ISchemaManagerItem"/> instance.</param>
private void AddUIdIfNotNull(List <Guid> list, ISchemaManagerItem item)
{
if (item != null)
{
list.AddIfNotExists(item.UId);
}
}
public override Select GetEntitiesSelect()
{
Select sysAdminUnitInRoleSelect = GetSysAdminUnitInRoleSelect();
ISchemaManagerItem <EntitySchema> invoiceEntitySchema =
UserConnection.EntitySchemaManager.FindItemByName(InvoiceSchemaName);
Guid sysImage = GetNotificationImage(InvoiceVisaSchemaName, RemindingConsts.NotificationTypeRemindingId);
Guid[] finallyStatuses = NotificationUtilities.GetFinallyVisaStatuses(UserConnection);
string invoiceCaption = invoiceEntitySchema.Caption;
QueryCase queryCase = GetQueryCase();
var entitiesSelect = new Select(UserConnection)
.Column(InvoiceVisaSchemaName, "Id")
.Column(InvoiceVisaSchemaName, "CreatedOn")
.Column(InvoiceVisaSchemaName, "CreatedById")
.Column(InvoiceVisaSchemaName, "ModifiedOn")
.Column(InvoiceVisaSchemaName, "ModifiedById")
.Column(InvoiceVisaSchemaName, "ProcessListeners")
.Column(InvoiceVisaSchemaName, "Objective")
.Column(queryCase).As("VisaOwnerId")
.Column(InvoiceVisaSchemaName, "IsAllowedToDelegate")
.Column(InvoiceVisaSchemaName, "DelegatedFromId")
.Column(InvoiceVisaSchemaName, "StatusId")
.Column(InvoiceVisaSchemaName, "SetById")
.Column(InvoiceVisaSchemaName, "SetDate")
.Column(InvoiceVisaSchemaName, "IsCanceled")
.Column(InvoiceVisaSchemaName, "Comment")
.Column(Column.Parameter(InvoiceSchemaName)).As("VisaSchemaName")
.Column(InvoiceSchemaName, "Number").As("Title")
.Column(InvoiceSchemaName, "Id").As("VisaObjectId")
.Column(InvoiceSchemaName, "StartDate").As("Date")
.Column("Account", "Name").As("Account")
.Column("Contact", "Name").As("Contact")
.Column(Column.Parameter(Guid.Empty)).As("VisaSchemaTypeId")
.Column(Column.Parameter(string.Empty)).As("VisaTypeName")
.Column(Column.Parameter(invoiceCaption)).As("VisaSchemaCaption")
.Column(Column.Parameter(InvoiceSchemaName)).As("SchemaName")
.Column(Column.Parameter(sysImage)).As("ImageId")
.Distinct()
.From(InvoiceVisaSchemaName)
.InnerJoin(InvoiceSchemaName).On(InvoiceSchemaName, "Id").IsEqual(InvoiceVisaSchemaName, "InvoiceId")
.InnerJoin(sysAdminUnitInRoleSelect).As("SysAdminUnitRole")
.On(InvoiceVisaSchemaName, "VisaOwnerId").IsEqual("SysAdminUnitRole", "SysAdminUnitRoleId")
.LeftOuterJoin("SysUserInRole")
.On("SysUserInRole", "SysRoleId").IsEqual("SysAdminUnitRole", "SysAdminUnitId")
.LeftOuterJoin("Account").On("Account", "Id").IsEqual(InvoiceSchemaName, "AccountId")
.LeftOuterJoin("Contact").On("Contact", "Id").IsEqual(InvoiceSchemaName, "ContactId")
.Where(InvoiceVisaSchemaName, "VisaOwnerId").In(
new Select(UserConnection).Column("SysAdminUnitRoleId").From("SysAdminUnitInRole")
.Where("SysAdminUnitId").IsEqual(Column.Parameter(_sysAdminUnit)))
.And(InvoiceVisaSchemaName, "StatusId").Not().In(Column.Parameters(finallyStatuses))
.And(InvoiceVisaSchemaName, "IsCanceled").IsEqual(Column.Parameter(false)) as Select;
return(entitiesSelect);
}
/// <summary>
/// Returns section required entities unique identifiers list.
/// </summary>
/// <param name="sectionMainEntity">Section main entity <see cref="ISchemaManagerItem"/> instance.</param>
/// <returns>Section required entities unique identifiers list.</returns>
private IEnumerable <Guid> GetSectionRequiredEntityIds(ISchemaManagerItem sectionMainEntity)
{
var result = new List <Guid>();
result.AddIfNotExists(sectionMainEntity.UId);
foreach (var entityNameSuffix in _sectionRelatedEntitySufixes)
{
AddUIdIfNotNull(result, EntitySchemaManager.FindItemByName(sectionMainEntity.Name + entityNameSuffix));
}
return(result);
}
/// <summary>
/// Checks whether current users has read access right for the feed.
/// </summary>
/// <param name="entitySchemaUId">Feed entity schema unique identifier.</param>
/// <param name="primaryColumnValue">Feed unique identifier.</param>
private void CheckChannelReadRights(Guid entitySchemaUId, Guid primaryColumnValue)
{
SchemaRecordRightLevels canReadRight = Terrasoft.Core.DB.SchemaRecordRightLevels.CanRead;
ISchemaManagerItem <CoreEntitySchema> schemaItem = UserConnection.EntitySchemaManager.GetItemByUId(entitySchemaUId);
SchemaRecordRightLevels schemaRightLevel = DBSecurityEngine.GetEntitySchemaRecordRightLevel(schemaItem.Name, primaryColumnValue);
if ((schemaRightLevel & canReadRight) != canReadRight)
{
throw new SecurityException(new LocalizableString(UserConnection.Workspace.ResourceStorage,
"SocialSubscriptionService", "LocalizableStrings.SocialChannelCanNotBeRead.Value"));
}
}
/// <summary>
/// Gets <see cref="ISchemaManagerItem"/> manager design item for <paramref name="item"/>.
/// </summary>
/// <param name="item"><see cref="EntitySchemaManager"/> manager item.</param>
/// <returns><see cref="ISchemaManagerItem"/> manager design item.</returns>
protected virtual ISchemaManagerItem <EntitySchema> GetDesignItem(ISchemaManagerItem <EntitySchema> item)
{
ISchemaManagerItem managerItem;
try {
(Guid schemaId, Guid schemaRealUId) = _utils.GetSchemaPackageInfo(item.Name, _packageUId);
managerItem = _entitySchemaManager.DesignItem(_userConnection, schemaRealUId);
managerItem.Id = schemaId;
var instance = managerItem.Instance as EntitySchema;
instance.Id = schemaId;
} catch (NullReferenceException) {
managerItem = _entitySchemaManager.CreateDesignSchema(_userConnection,
item.UId, _packageUId, true);
}
return(_entitySchemaManager.FindDesignItem(_userConnection, managerItem.UId) as ISchemaManagerItem <EntitySchema>);
}
public ProcessCheckResult CheckParameters(Guid processUId, List <ProcessCheckParameter> checkParameters)
{
if ((checkParameters == null) || (checkParameters.Count == 0))
{
return(new ProcessCheckResult {
IsValid = true
});
}
ISchemaManagerItem <ProcessSchema> processManagerItem =
UserConnection.ProcessSchemaManager.FindItemByUId(processUId);
if (processManagerItem == null)
{
string errorText = new LocalizableString(UserConnection.ResourceStorage, "ProcessValidationService",
"LocalizableStrings.ProcessNotFoundErrorText.Value").ToString();
return(new ProcessCheckResult {
IsValid = false,
ErrorText = errorText
});
}
ProcessSchema processSchema = UserConnection.ProcessSchemaManager.GetInstanceByUId(processUId);
var parameters = processSchema.Parameters;
ProcessCheckParameterComparer comparer = new ProcessCheckParameterComparer();
List <ProcessCheckParameter> invalidParameters = checkParameters
.Where(checkParameter => !(parameters
.Select(parameter => new ProcessCheckParameter()
{
Name = parameter.Name,
DataValueTypes = new List <string>(1)
{
parameter.DataValueType.Name
}
})
.Where(parameter => checkParameters.Contains(parameter, comparer))
.ToList <ProcessCheckParameter>()).Contains(checkParameter, comparer)
)
.ToList();
return(new ProcessCheckResult {
IsValid = (invalidParameters.Count == 0),
InvalidParameters = invalidParameters
});
}
/// <summary>
/// Sets <see cref="EntitySchema"/> property <paramref name="propertyName"/> enabled.
/// </summary>
/// <param name="item"><see cref="ISchemaManagerItem"/> implementation instance.</param>
/// <param name="propertyName"><see cref="EntitySchema"/> property name.</param>
private void SetEntitySchemaPropertyEnabled(ISchemaManagerItem <EntitySchema> item, string propertyName)
{
if (item == null)
{
return;
}
var designItem = GetDesignItem(item);
if (!designItem.Instance.HasProperty(propertyName))
{
return;
}
var propertyValue = designItem.Instance.GetPropertyValue(propertyName) as bool?;
if (!propertyValue.HasValue || propertyValue.Value)
{
return;
}
designItem.Instance.SetPropertyValue(propertyName, true);
_entitySchemaManager.SaveSchema(designItem, _userConnection);
}
private ResponceApplyChanges ApplyColumnsChanges(Guid entitySchemaId, List <ChangedColumn> changedColumns)
{
ResponceApplyChanges responce = new ResponceApplyChanges();
responce.success = true;
var entitySchemaManager = UserConnection.EntitySchemaManager;
string baseCaption = string.Empty;
var baseEntitySchema = entitySchemaManager.FindItemByUId(entitySchemaId);
if (baseEntitySchema != null)
{
baseCaption = baseEntitySchema.Caption;
}
ISchemaManagerItem designSchemaItem = entitySchemaManager.DesignItemInCustomPackage(UserConnection, entitySchemaId);
if (baseCaption != string.Empty)
{
designSchemaItem.Caption = baseCaption;
}
var entitySchema = designSchemaItem.Instance as EntitySchema;
if (baseCaption != string.Empty)
{
entitySchema.Caption = baseCaption;
}
Dictionary <string, string> newLookupsCollection = new Dictionary <string, string>();
Dictionary <string, EntitySchema> newLookupsEntitiesCollection = new Dictionary <string, EntitySchema>();
var newLookups = changedColumns.Where(c => c.IsNewLookup && entitySchema.Columns.FindByName(c.Name) == null);
if (newLookups != null)
{
foreach (ChangedColumn item in newLookups)
{
var dictionaryEntitySchema = entitySchemaManager.FindItemByName(item.ReferenceSchemaName);
if (dictionaryEntitySchema != null)
{
responce.Code = "Error.Dictionary.Exists";
responce.Message = item.ReferenceSchemaName;
responce.success = false;
return(responce);
}
newLookupsCollection.Add(item.ReferenceSchemaName, item.ReferenceSchemaCaption);
}
}
if (newLookupsCollection.Count > 0)
{
var sysFolderId = (new Select(UserConnection)
.Column("Id")
.From("SysSchemaFolder")
.Where("ParentId").IsNull() as Select)
.ExecuteScalar <Guid>();
var baseLookupEntitySchema = entitySchemaManager.GetInstanceByName("BaseLookup");
var sysLookup = entitySchemaManager.GetInstanceByName("SysLookup");
var customPackageId = WorkspaceUtilities.ForceGetCustomPackageUId(UserConnection);
foreach (var item in newLookupsCollection)
{
var lookupEntitySchemaItemUId = Guid.NewGuid();
object schemaNamePrefix;
var lookupSchemaName = item.Key;
if (SysSettings.TryGetValue(UserConnection, "SchemaNamePrefix", out schemaNamePrefix) &&
!schemaNamePrefix.Equals(string.Empty))
{
lookupSchemaName = string.Concat(schemaNamePrefix, lookupSchemaName);
}
ISchemaManagerItem <EntitySchema> lookupEntitySchemaItem = entitySchemaManager.CreateSchema(lookupSchemaName,
baseLookupEntitySchema, UserConnection, lookupEntitySchemaItemUId, false);
lookupEntitySchemaItem.Caption = item.Value;
var lookupEntitySchema = (EntitySchema)lookupEntitySchemaItem.Instance;
lookupEntitySchema.Caption = item.Value;
entitySchemaManager.SaveDesignedItemInSessionData(lookupEntitySchemaItem);
entitySchemaManager.SaveDesignedItemFolderIdInSessionData(UserConnection, lookupEntitySchemaItemUId, sysFolderId);
entitySchemaManager.SaveDesignedItemPackageUIdInSessionData(UserConnection, lookupEntitySchemaItemUId, customPackageId);
entitySchemaManager.SaveSchema(lookupEntitySchemaItemUId, UserConnection);
try {
responce = ApplyDbChanges(responce, lookupEntitySchema);
} catch (Exception) {
responce.success = false;
responce.Code = "Error.DbMetaActions.LookupApply";
return(responce);
}
newLookupsEntitiesCollection.Add(item.Key, lookupEntitySchema);
Entity sysLookupEntity = sysLookup.CreateEntity(UserConnection);
sysLookupEntity.SetColumnValue("Id", Guid.NewGuid());
sysLookupEntity.SetColumnValue("Name", item.Value);
sysLookupEntity.SetColumnValue("Description", string.Empty);
sysLookupEntity.SetColumnValue("SysFolderId", new Guid("80AB12C2-F36B-1410-A883-16D83CAB0980")); //// SysLookupFolder - General
sysLookupEntity.SetColumnValue("SysEntitySchemaUId", lookupEntitySchema.UId);
sysLookupEntity.SetColumnValue("ProcessListeners", 0);
sysLookupEntity.Save();
}
}
foreach (ChangedColumn item in changedColumns)
{
EntitySchemaColumn column = entitySchema.Columns.FindByName(item.Name);
if (column == null)
{
DataValueType dataValueType = GetDataValueTypeByTypeName(item.TypeGroupName, item.TypeName);
column = entitySchema.Columns.CreateItem();
column.UId = Guid.NewGuid();
column.UsageType = EntitySchemaColumnUsageType.General;
column.Name = item.Name;
column.DataValueType = dataValueType;
column.DataValueTypeManager = dataValueType.DataValueTypeManager;
column.DataValueTypeUId = dataValueType.UId;
if (dataValueType.IsLookup || dataValueType.IsMultiLookup)
{
EntitySchema referenceEntitySchema;
if (item.IsNewLookup)
{
referenceEntitySchema = newLookupsEntitiesCollection.First(l => l.Key == item.ReferenceSchemaName).Value;
}
else
{
referenceEntitySchema = entitySchemaManager.GetInstanceByName(item.ReferenceSchemaName);
}
column.ReferenceSchema = referenceEntitySchema;
column.ReferenceSchemaUId = referenceEntitySchema.UId;
}
entitySchema.Columns.Add(column);
}
column.Caption = item.Caption;
column.IsSimpleLookup = item.IsEnum;
column.RequirementType = item.IsRequired ?
EntitySchemaColumnRequirementType.ApplicationLevel : EntitySchemaColumnRequirementType.None;
column.IsMultiLineText = item.IsMultiline;
}
entitySchemaManager.SaveDesignedItemInSessionData(UserConnection, entitySchema as MetaSchema, entitySchema.UId);
try {
entitySchemaManager.SaveSchema(entitySchema.UId, UserConnection, false);
responce = ApplyDbChanges(responce, entitySchema, true);
responce.success = true;
} catch (Exception) {
responce.success = false;
responce.Code = "Error.DbMetaActions.EntitySchemaApply";
}
return(responce);
}
/// <summary>
/// Creates information about processing error.
/// </summary>
/// <param name="cellRefference">Information about excel cell.</param>
/// <param name="entitySchemaUId">Entity schema unique identifier.</param>
/// <param name="missingValue">Exception message.</param>
/// <returns></returns>
private string CreateColumnProcessErrorMessage(Guid entitySchemaUId, string missingValue)
{
ISchemaManagerItem <EntitySchema> schema = UserConnection.EntitySchemaManager.GetItemByUId(entitySchemaUId);
return(string.Format(ErrorMessageTemplate, schema.Caption, missingValue));
}
