public static void Initialize(IContext context)
{
StatusUtilities.Initialize(context: context);
}
private static void UpdateOrInsert(
Context context,
string loginId,
string deptCode,
string deptName,
string userCode,
string name,
string mailAddress,
List <KeyValuePair <LdapExtendedAttribute, string> > attributes,
ParameterAccessor.Parts.Ldap ldap,
DateTime synchronizedTime)
{
var deptExists = !deptCode.IsNullOrEmpty() && !deptName.IsNullOrEmpty();
var deptSettings = !ldap.LdapDeptCode.IsNullOrEmpty() && !ldap.LdapDeptName.IsNullOrEmpty();
var statements = new List <SqlStatement>();
if (deptExists)
{
statements.Add(Rds.UpdateOrInsertDepts(
param: Rds.DeptsParam()
.TenantId(ldap.LdapTenantId)
.DeptCode(deptCode)
.DeptName(deptName),
where : Rds.DeptsWhere().DeptCode(deptCode)));
}
var param = Rds.UsersParam()
.TenantId(ldap.LdapTenantId)
.LoginId(loginId)
.UserCode(userCode)
.Name(name)
.DeptId(
sub: Rds.SelectDepts(
column: Rds.DeptsColumn().DeptId(),
where : Rds.DeptsWhere().DeptCode(deptCode)),
_using: deptExists)
.DeptId(0, _using: deptSettings && !deptExists)
.LdapSearchRoot(ldap.LdapSearchRoot)
.SynchronizedTime(synchronizedTime);
attributes?.ForEach(attributeAndName =>
param.Add(
$"\"Users\".\"{attributeAndName.Key.ColumnName}\"",
attributeAndName.Key.ColumnName,
attributeAndName.Value));
statements.Add(Rds.UpdateOrInsertUsers(
param: param,
where : Rds.UsersWhere().LoginId(loginId),
addUpdatorParam: false,
addUpdatedTimeParam: false));
if (!mailAddress.IsNullOrEmpty())
{
statements.Add(Rds.PhysicalDeleteMailAddresses(
where : Rds.MailAddressesWhere()
.OwnerType("Users")
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))));
statements.Add(Rds.InsertMailAddresses(
param: Rds.MailAddressesParam()
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))
.OwnerType("Users")
.MailAddress(mailAddress)));
}
var ss = new SiteSettings();
statements.Add(StatusUtilities.UpdateStatus(
tenantId: ldap.LdapTenantId, type: StatusUtilities.Types.DeptsUpdated));
statements.Add(StatusUtilities.UpdateStatus(
tenantId: ldap.LdapTenantId, type: StatusUtilities.Types.UsersUpdated));
Repository.ExecuteNonQuery(
context: context,
transactional: true,
statements: statements.ToArray());
}
public static string ImportSitePackage(
Context context,
SiteSettings ss,
SitePackageApiModel apiData = null)
{
var includeData = Parameters.SitePackage.IncludeDataOnImport != OptionTypes.Disabled &&
(apiData?.SelectedSites.Any(site => site.IncludeData == true)
?? context.Forms.Bool("IncludeData"));
var includeSitePermission = Parameters.SitePackage.IncludeSitePermissionOnImport != OptionTypes.Disabled &&
(apiData?.IncludeSitePermission
?? context.Forms.Bool("IncludeSitePermission"));
var includeRecordPermission = Parameters.SitePackage.IncludeRecordPermissionOnImport != OptionTypes.Disabled &&
(apiData?.IncludeRecordPermission
?? context.Forms.Bool("IncludeRecordPermission"));
var includeColumnPermission = Parameters.SitePackage.IncludeColumnPermissionOnImport != OptionTypes.Disabled &&
(apiData?.IncludeColumnPermission
?? context.Forms.Bool("IncludeColumnPermission"));
var includeNotifications = Parameters.SitePackage.IncludeNotificationsOnImport != OptionTypes.Disabled &&
(apiData?.IncludeNotifications
?? context.Forms.Bool("IncludeNotifications"));
var includeReminders = Parameters.SitePackage.IncludeRemindersOnImport != OptionTypes.Disabled &&
(apiData?.IncludeReminders
?? context.Forms.Bool("IncludeReminders"));
if (ss.SiteId == 0)
{
ss.PermissionType = context.SiteTopPermission();
}
if (!Parameters.SitePackage.Import ||
!context.CanManageSite(ss: ss))
{
return(Messages.ResponseInvalidRequest(context: context).ToJson());
}
if (includeData && context.ContractSettings.Import == false)
{
return(Messages.ResponseInvalidRequest(context: context).ToJson());
}
var sitePackage = apiData == null
? GetSitePackageFromPostedFile(context : context)
: GetSitePackage(
context: context,
ss: ss,
apiData: apiData);
if (sitePackage == null)
{
return(Messages.ResponseInvalidRequest(context: context).ToJson());
}
if (context.ContractSettings.SitesLimit(
context: context,
number: sitePackage.Sites.Count()))
{
return(Messages.ResponseSitesLimit(context: context).ToJson());
}
if (includeData)
{
if (Parameters.General.ImportMax > 0 &&
Parameters.General.ImportMax < sitePackage.Data
.SelectMany(o => o.Body)
.Count())
{
return(Messages.ResponseImportMax(
context: context,
data: Parameters.General.ImportMax.ToString())
.ToJson());
}
if (sitePackage.Data.Any(o => o.Header.Any(p =>
context.ContractSettings.ItemsLimit(
context: context,
siteId: p.SiteId,
number: o.Body.Count()))))
{
return(Messages.ResponseItemsLimit(
context: context,
data: Parameters.General.ImportMax.ToString())
.ToJson());
}
}
sitePackage.ConvertInheritPermissionInNotIncluded();
sitePackage.HeaderInfo.SavedBaseSiteId = apiData?.TargetSiteId
?? context.SiteId;
sitePackage.HeaderInfo.SavedInheritPermission = ss.InheritPermission;
foreach (var conv in sitePackage.HeaderInfo.Convertors)
{
conv.SiteTitle = conv.SiteId == sitePackage.HeaderInfo.BaseSiteId &&
!String.IsNullOrEmpty(apiData?.SiteTitle)
? apiData.SiteTitle
: conv.SiteTitle;
var response = Repository.ExecuteScalar_response(
context: context,
transactional: true,
selectIdentity: true,
statements: new SqlStatement[]
{
Rds.InsertItems(
selectIdentity: true,
param: Rds.ItemsParam()
.ReferenceType("Sites")
.Title(conv.SiteTitle)),
Rds.UpdateItems(
where : Rds.ItemsWhere().ReferenceId(raw: Def.Sql.Identity),
param: Rds.ItemsParam().SiteId(raw: Def.Sql.Identity)),
});
conv.SavedSiteId = response.Id;
}
foreach (var conv in sitePackage.HeaderInfo.Convertors)
{
var packageSiteModel = sitePackage.Sites
.Where(e => e.SiteId == conv.SiteId)
.FirstOrDefault();
packageSiteModel.SetSavedIds(
context: context,
ss: ss,
sitePackage: sitePackage,
savedSiteId: conv.SavedSiteId.ToLong(),
includeSitePermission: includeSitePermission &&
sitePackage.HeaderInfo.IncludeSitePermission);
packageSiteModel.SiteSettings = packageSiteModel.GetSavedSiteSettings(
context: context,
header: sitePackage.HeaderInfo,
includeColumnPermission: includeColumnPermission,
permissionIdList: sitePackage.PermissionIdList,
includeNotifications: includeNotifications,
includeReminders: includeReminders);
Repository.ExecuteScalar_response(
context: context,
transactional: true,
statements: new SqlStatement[]
{
Rds.InsertSites(param: Rds.SitesParam()
.SiteId(packageSiteModel.SavedSiteId)
.TenantId(packageSiteModel.SavedTenantId)
.Title(conv.SiteTitle)
.Body(packageSiteModel.Body)
.GridGuide(packageSiteModel.GridGuide)
.EditorGuide(packageSiteModel.EditorGuide)
.ReferenceType(packageSiteModel.ReferenceType.MaxLength(32))
.ParentId(packageSiteModel.SavedParentId)
.InheritPermission(packageSiteModel.SavedInheritPermission)
.SiteSettings(packageSiteModel.SiteSettings.ToJson())
.Publish(packageSiteModel.Publish)
.DisableCrossSearch(packageSiteModel.DisableCrossSearch)
.Comments(packageSiteModel.Comments.ToJson())),
Rds.PhysicalDeleteLinks(
where : Rds.LinksWhere().SourceId(packageSiteModel.SavedSiteId)),
LinkUtilities.Insert(link: packageSiteModel.SiteSettings.Links
?.Where(o => o.SiteId > 0)
.Select(o => o.SiteId)
.Distinct()
.ToDictionary(o => o, o => packageSiteModel.SavedSiteId)
?? new Dictionary <long, long>()),
Rds.InsertPermissions(
param: Rds.PermissionsParam()
.ReferenceId(packageSiteModel.SavedSiteId)
.DeptId(0)
.UserId(context.UserId)
.PermissionType(Permissions.Manager()),
_using: packageSiteModel.SavedInheritPermission == packageSiteModel.SavedSiteId),
});
var siteModel = new SiteModel(
context: context,
siteId: packageSiteModel.SavedSiteId);
var fullText = siteModel.FullText(
context: context,
ss: siteModel.SiteSettings);
Repository.ExecuteNonQuery(
context: context,
transactional: true,
statements: Rds.UpdateItems(
where : Rds.ItemsWhere()
.ReferenceId(packageSiteModel.SavedSiteId),
param: Rds.ItemsParam()
.FullText(fullText, _using: fullText != null)
.SearchIndexCreatedTime(DateTime.Now, _using: fullText != null)));
}
var idHash = sitePackage.GetIdHashFromConverters();
foreach (long savedSiteId in sitePackage.HeaderInfo.Convertors.Select(e => e.SavedSiteId))
{
var siteModel = new SiteModel(
context: context,
siteId: savedSiteId);
switch (siteModel.ReferenceType)
{
case "Wikis":
var wikiModel = new WikiModel(
context: context,
ss: siteModel.SiteSettings)
{
SiteId = siteModel.SiteId,
Title = siteModel.Title,
Body = siteModel.Body,
Comments = siteModel.Comments
};
wikiModel.Create(
context: context,
ss: siteModel.SiteSettings);
var wikiId = Repository.ExecuteScalar_long(
context: context,
statements: Rds.SelectWikis(
top: 1,
column: Rds.WikisColumn().WikiId(),
where : Rds.WikisWhere().SiteId(siteModel.SiteId)));
idHash.Add(savedSiteId, wikiId);
break;
default:
Search.Indexes.Create(
context: context,
ss: siteModel.SiteSettings,
id: siteModel.SiteId);
break;
}
}
SiteInfo.Reflesh(context: context);
int dataCount = 0;
if (includeData)
{
if (sitePackage.Data.Any())
{
ImportItems(
context: context,
sitePackage: sitePackage,
idHash: idHash);
sitePackage.ConvertDataId(
context: context,
idHash: idHash);
dataCount = ImportData(
context: context,
sitePackage: sitePackage,
idHash: idHash);
}
}
if (sitePackage.HeaderInfo.Convertors.Any())
{
foreach (var conv in sitePackage.HeaderInfo.Convertors)
{
if (conv.ReferenceType == "Sites")
{
if ((!conv.Order.IsNullOrEmpty() && conv.Order.Equals("[]") == false))
{
var newOrders = new List <long>();
var orders = conv.Order.Deserialize <List <long> >()?.ToList()
?? new List <long>();
orders.ForEach(e => newOrders.Add(idHash.Get(e)));
if (newOrders.Any())
{
new OrderModel()
{
ReferenceId = conv.SavedSiteId.ToLong(),
ReferenceType = "Sites",
OwnerId = 0,
Data = newOrders
}.UpdateOrCreate(
context: context,
ss: ss);
}
}
}
}
var response = Repository.ExecuteScalar_response(
context: context,
transactional: true);
}
if (sitePackage.Permissions.Any())
{
foreach (var conv in sitePackage.HeaderInfo.Convertors)
{
var packageSiteModel = sitePackage.Sites
.Where(e => e.SiteId == conv.SiteId)
.FirstOrDefault();
var packagePermissionModel = sitePackage.Permissions
.Where(e => e.SiteId == conv.SiteId)
.FirstOrDefault();
foreach (var permissionShortModel in packagePermissionModel.Permissions)
{
if (includeSitePermission == false)
{
if (permissionShortModel.ReferenceId == packagePermissionModel.SiteId)
{
continue;
}
}
if ((includeRecordPermission == false) || (dataCount == 0))
{
if (permissionShortModel.ReferenceId != packagePermissionModel.SiteId)
{
continue;
}
}
var idConverter = new IdConverter(
context: context,
siteId: packageSiteModel.SavedSiteId,
permissionShortModel: permissionShortModel,
permissionIdList: sitePackage.PermissionIdList,
convertSiteId: idHash[permissionShortModel.ReferenceId]);
var exists = Rds.ExecuteScalar_int(
context: context,
statements: Rds.SelectPermissions(
column: Rds.PermissionsColumn().ReferenceId(),
where : Rds.PermissionsWhere()
.ReferenceId(idHash[permissionShortModel.ReferenceId])
.DeptId(idConverter.ConvertDeptId)
.GroupId(idConverter.ConvertGroupId)
.UserId(idConverter.ConvertUserId))) > 0;
if (idConverter.Convert == true && !exists)
{
Repository.ExecuteNonQuery(
context: context,
transactional: true,
statements: Rds.InsertPermissions(
param: Rds.PermissionsParam()
.ReferenceId(idHash[permissionShortModel.ReferenceId])
.DeptId(idConverter.ConvertDeptId)
.GroupId(idConverter.ConvertGroupId)
.UserId(idConverter.ConvertUserId)
.PermissionType(permissionShortModel.PermissionType)));
}
}
}
}
Repository.ExecuteNonQuery(
context: context,
statements: StatusUtilities.UpdateStatus(
tenantId: context.TenantId,
type: StatusUtilities.Types.UsersUpdated));
if (apiData == null)
{
SessionUtilities.Set(
context: context,
message: Messages.SitePackageImported(
context: context,
data: new string[]
{
sitePackage.HeaderInfo.Convertors.Count().ToString(),
dataCount.ToString()
}));
return(new ResponseCollection()
.Href(url: Locations.ItemIndex(
context: context,
id: ss.SiteId))
.ToJson());
}
else
{
return(sitePackage.HeaderInfo.Convertors
.Select(o => new
{
OldSiteId = o.SiteId,
NewSiteId = o.SavedSiteId,
ReferenceType = o.ReferenceType,
Title = o.SiteTitle
})
.ToJson());
}
}
private static void UpdateOrInsert(
Context context,
SearchResult result,
ParameterAccessor.Parts.Ldap ldap,
DateTime synchronizedTime)
{
var deptCode = result.Property(
context: context,
name: ldap.LdapDeptCode,
pattern: ldap.LdapDeptCodePattern);
var deptName = result.Property(
context: context,
name: ldap.LdapDeptName,
pattern: ldap.LdapDeptNamePattern);
var deptExists = !deptCode.IsNullOrEmpty() && !deptName.IsNullOrEmpty();
var deptSettings = !ldap.LdapDeptCode.IsNullOrEmpty() && !ldap.LdapDeptName.IsNullOrEmpty();
var userCode = result.Property(
context: context,
name: ldap.LdapUserCode,
pattern: ldap.LdapUserCodePattern);
var loginId = LoginId(
context: context,
ldap: ldap,
result: result);
var name = Name(
context: context,
loginId: loginId,
result: result,
ldap: ldap);
var mailAddress = result.Property(
context: context,
name: ldap.LdapMailAddress,
pattern: ldap.LdapMailAddressPattern);
var statements = new List <SqlStatement>();
if (deptExists)
{
statements.Add(Rds.UpdateOrInsertDepts(
param: Rds.DeptsParam()
.TenantId(ldap.LdapTenantId)
.DeptCode(deptCode)
.DeptName(deptName),
where : Rds.DeptsWhere().DeptCode(deptCode)));
}
var param = Rds.UsersParam()
.TenantId(ldap.LdapTenantId)
.LoginId(loginId)
.UserCode(userCode)
.Name(name)
.DeptId(
sub: Rds.SelectDepts(
column: Rds.DeptsColumn().DeptId(),
where : Rds.DeptsWhere().DeptCode(deptCode)),
_using: deptExists)
.DeptId(0, _using: deptSettings && !deptExists)
.LdapSearchRoot(ldap.LdapSearchRoot)
.SynchronizedTime(synchronizedTime);
ldap.LdapExtendedAttributes?.ForEach(attribute =>
param.Add(
$"[Users].[{attribute.ColumnName}]",
attribute.ColumnName,
result.Property(
context: context,
name: attribute.Name,
pattern: attribute.Pattern)));
statements.Add(Rds.UpdateOrInsertUsers(
param: param,
where : Rds.UsersWhere().LoginId(loginId),
addUpdatorParam: false,
addUpdatedTimeParam: false));
if (!mailAddress.IsNullOrEmpty())
{
statements.Add(Rds.PhysicalDeleteMailAddresses(
where : Rds.MailAddressesWhere()
.OwnerType("Users")
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))));
statements.Add(Rds.InsertMailAddresses(
param: Rds.MailAddressesParam()
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))
.OwnerType("Users")
.MailAddress(mailAddress)));
}
var ss = new SiteSettings();
statements.Add(StatusUtilities.UpdateStatus(
tenantId: ldap.LdapTenantId, type: StatusUtilities.Types.DeptsUpdated));
statements.Add(StatusUtilities.UpdateStatus(
tenantId: ldap.LdapTenantId, type: StatusUtilities.Types.UsersUpdated));
Repository.ExecuteNonQuery(
context: context,
transactional: true,
statements: statements.ToArray());
}
public AssemblyVersion(Context context)
{
SetByString(StatusUtilities.AssemblyVersion(context: context));
}
private static void UpdateOrInsert(
string loginId,
DirectoryEntry entry,
ParameterAccessor.Parts.Ldap ldap,
DateTime synchronizedTime)
{
var deptCode = entry.Property(ldap.LdapDeptCode, ldap.LdapDeptCodePattern);
var deptName = entry.Property(ldap.LdapDeptName, ldap.LdapDeptNamePattern);
var deptExists = !deptCode.IsNullOrEmpty() && !deptName.IsNullOrEmpty();
var userCode = entry.Property(ldap.LdapUserCode, ldap.LdapUserCodePattern);
var name = Name(loginId, entry, ldap);
var mailAddress = entry.Property(ldap.LdapMailAddress, ldap.LdapMailAddressPattern);
var statements = new List <SqlStatement>();
if (deptExists)
{
statements.Add(Rds.UpdateOrInsertDepts(
param: Rds.DeptsParam()
.TenantId(ldap.LdapTenantId)
.DeptCode(deptCode)
.DeptName(deptName),
where : Rds.DeptsWhere().DeptCode(deptCode)));
}
var param = Rds.UsersParam()
.TenantId(ldap.LdapTenantId)
.LoginId(loginId)
.UserCode(userCode)
.Name(name)
.DeptId(
sub: Rds.SelectDepts(
column: Rds.DeptsColumn().DeptId(),
where : Rds.DeptsWhere().DeptCode(deptCode)),
_using: deptExists)
.DeptId(0, _using: !deptExists)
.LdapSearchRoot(ldap.LdapSearchRoot)
.SynchronizedTime(synchronizedTime);
ldap.LdapExtendedAttributes?.ForEach(attribute =>
param.Add(
$"[Users].[{attribute.ColumnName}]",
attribute.ColumnName,
entry.Property(attribute.Name, attribute.Pattern)));
statements.Add(Rds.UpdateOrInsertUsers(
param: param,
where : Rds.UsersWhere().LoginId(loginId),
addUpdatorParam: false,
addUpdatedTimeParam: false));
if (!mailAddress.IsNullOrEmpty())
{
statements.Add(Rds.PhysicalDeleteMailAddresses(
where : Rds.MailAddressesWhere()
.OwnerType("Users")
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))));
statements.Add(Rds.InsertMailAddresses(
param: Rds.MailAddressesParam()
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))
.OwnerType("Users")
.MailAddress(mailAddress)));
}
statements.Add(StatusUtilities.UpdateStatus(
StatusUtilities.Types.DeptsUpdated,
tenantId: ldap.LdapTenantId));
statements.Add(StatusUtilities.UpdateStatus(
StatusUtilities.Types.UsersUpdated,
tenantId: ldap.LdapTenantId));
Rds.ExecuteNonQuery(
transactional: true,
statements: statements.ToArray());
}
