public static string ImportSitePackage(Context context, SiteSettings ss)
{
var includeData = context.Forms.Bool("IncludeData");
var includeSitePermission = context.Forms.Bool("IncludeSitePermission");
var includeRecordPermission = context.Forms.Bool("IncludeRecordPermission");
var includeColumnPermission = context.Forms.Bool("IncludeColumnPermission");
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 serializer = new JsonSerializer();
using (var ms = new System.IO.MemoryStream(
buffer: context.PostedFiles.FirstOrDefault().Byte(),
writable: false))
using (var sr = new System.IO.StreamReader(ms, Encoding.UTF8))
using (var reader = new JsonTextReader(sr))
{
var sitePackage = serializer.Deserialize <SitePackage>(reader);
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.HeaderInfo.SavedBaseSiteId = context.SiteId;
sitePackage.HeaderInfo.SavedInheritPermission = ss.InheritPermission;
foreach (var conv in sitePackage.HeaderInfo.Convertors)
{
var response = Rds.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);
Rds.ExecuteScalar_response(
context: context,
transactional: true,
statements: new SqlStatement[]
{
Rds.InsertSites(param: Rds.SitesParam()
.SiteId(packageSiteModel.SavedSiteId)
.TenantId(packageSiteModel.SavedTenantId)
.Title(packageSiteModel.Title)
.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)
.Comments(packageSiteModel.Comments.ToJson())),
Rds.PhysicalDeleteLinks(
where : Rds.LinksWhere().SourceId(packageSiteModel.SavedSiteId)),
LinkUtilities.Insert(link: packageSiteModel.SiteSettings.Links?
.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);
Rds.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 = Rds.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;
}
}
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);
}
}
}
}
var response = Rds.ExecuteScalar_response(
context: context,
transactional: true,
statements: StatusUtilities.UpdateStatus(
tenantId: context.TenantId,
type: StatusUtilities.Types.SitesUpdated));
}
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]);
if (idConverter.Convert == true)
{
Rds.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)));
}
}
}
}
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());
}
}
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 exists = Rds.ExecuteScalar_int(
context: context,
statements: Rds.SelectUsers(
column: Rds.UsersColumn().UsersCount(),
where : Rds.UsersWhere().LoginId(
value: context.Sqls.EscapeValue(loginId),
_operator: context.Sqls.LikeWithEscape))) == 1;
var param = Rds.UsersParam()
.TenantId(ldap.LdapTenantId)
.LoginId(loginId, _using: !exists)
.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(
value: context.Sqls.EscapeValue(loginId),
_operator: context.Sqls.LikeWithEscape),
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(
value: context.Sqls.EscapeValue(loginId),
_operator: context.Sqls.LikeWithEscape)))));
statements.Add(Rds.InsertMailAddresses(
param: Rds.MailAddressesParam()
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(
value: context.Sqls.EscapeValue(loginId),
_operator: context.Sqls.LikeWithEscape)))
.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 void UpdateOrInsert(
Context context,
int tenantId,
string loginId,
string name,
string mailAddress,
DateTime synchronizedTime,
SamlAttributes attributes)
{
var deptCode = attributes[nameof(UserModel.DeptCode)];
var deptName = attributes[nameof(UserModel.Dept)];
var deptSettings = !deptCode.IsNullOrEmpty() &&
!deptName.IsNullOrEmpty();
var isEmptyDeptCode = deptCode == string.Empty;
var user = new UserModel().Get(
context: context,
ss: null,
where: Rds.UsersWhere()
.TenantId(tenantId)
.LoginId(loginId)
.Name(name)
.TenantManager(
attributes.TenantManager,
_using: attributes[nameof(UserModel.TenantManager)] != null)
.FirstName(
attributes[nameof(UserModel.FirstName)],
_using: attributes[nameof(UserModel.FirstName)] != null)
.LastName(
attributes[nameof(UserModel.LastName)],
_using: attributes[nameof(UserModel.LastName)] != null)
.FirstAndLastNameOrder(
attributes[nameof(UserModel.FirstAndLastNameOrder)],
_using: attributes[nameof(UserModel.FirstAndLastNameOrder)] != null)
.UserCode(
attributes[nameof(UserModel.UserCode)],
_using: attributes[nameof(UserModel.UserCode)] != null)
.Birthday(
attributes[nameof(UserModel.Birthday)],
_using: attributes[nameof(UserModel.Birthday)] != null)
.Gender(
attributes[nameof(UserModel.Gender)],
_using: attributes[nameof(UserModel.Gender)] != null)
.Language(
attributes[nameof(UserModel.Language)],
_using: attributes[nameof(UserModel.Language)] != null)
.TimeZone(
attributes[nameof(UserModel.TimeZone)],
_using: attributes[nameof(UserModel.TimeZone)] != null)
.DeptId(
sub: Rds.SelectDepts(
column: Rds.DeptsColumn().DeptId(),
where : Rds.DeptsWhere().DeptCode(deptCode)),
_using: deptSettings)
.Body(
attributes[nameof(UserModel.Body)],
_using: attributes[nameof(UserModel.Body)] != null));
if (!isEmptyDeptCode &&
user.AccessStatus == Databases.AccessStatuses.Selected)
{
if (mailAddress.IsNullOrEmpty())
{
return;
}
var addressCount = Rds.ExecuteScalar_long(
context: context,
statements: new[]
{
Rds.SelectMailAddresses(
dataTableName: "Count",
column: Rds.MailAddressesColumn().MailAddressesCount(),
where : Rds.MailAddressesWhere()
.OwnerType("Users")
.OwnerId(sub: Rds.SelectUsers(
column: Rds.UsersColumn().UserId(),
where : Rds.UsersWhere().LoginId(loginId)))
.MailAddress(mailAddress))
});
if (addressCount > 0)
{
return;
}
}
var statements = new List <SqlStatement>();
if (deptSettings)
{
statements.Add(Rds.UpdateOrInsertDepts(
param: Rds.DeptsParam()
.TenantId(tenantId)
.DeptCode(deptCode)
.DeptName(deptName),
where : Rds.DeptsWhere().DeptCode(deptCode)));
}
var param = Rds.UsersParam()
.TenantId(tenantId)
.LoginId(loginId)
.Name(name)
.TenantManager(attributes.TenantManager,
_using: attributes[nameof(UserModel.TenantManager)] != null)
.SynchronizedTime(synchronizedTime)
.FirstName(
attributes[nameof(UserModel.FirstName)],
_using: attributes[nameof(UserModel.FirstName)] != null)
.LastName(
attributes[nameof(UserModel.LastName)],
_using: attributes[nameof(UserModel.LastName)] != null)
.FirstAndLastNameOrder(
attributes[nameof(UserModel.FirstAndLastNameOrder)],
_using: attributes[nameof(UserModel.FirstAndLastNameOrder)] != null)
.UserCode(
attributes[nameof(UserModel.UserCode)],
_using: attributes[nameof(UserModel.UserCode)] != null)
.DeptId(
sub: Rds.SelectDepts(
column: Rds.DeptsColumn().DeptId(),
where : Rds.DeptsWhere().DeptCode(deptCode)),
_using: deptSettings)
.DeptId(0, _using: isEmptyDeptCode)
.Birthday(
attributes[nameof(UserModel.Birthday)],
_using: attributes[nameof(UserModel.Birthday)] != null)
.Gender(
attributes[nameof(UserModel.Gender)],
_using: attributes[nameof(UserModel.Gender)] != null)
.Language(
attributes[nameof(UserModel.Language)],
_using: attributes[nameof(UserModel.Language)] != null)
.TimeZone(
attributes[nameof(UserModel.TimeZone)],
_using: attributes[nameof(UserModel.TimeZone)] != null)
.Body(
attributes[nameof(UserModel.Body)],
_using: attributes[nameof(UserModel.Body)] != null);
statements.Add(Rds.UpdateOrInsertUsers(
param: param,
where : Rds.UsersWhere().TenantId(tenantId).LoginId(loginId),
addUpdatorParam: true,
addUpdatedTimeParam: true));
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(
tenantId: tenantId, type: StatusUtilities.Types.DeptsUpdated));
statements.Add(StatusUtilities.UpdateStatus(
tenantId: tenantId, type: StatusUtilities.Types.UsersUpdated));
Rds.ExecuteNonQuery(
context: context,
transactional: true,
statements: statements.ToArray());
}
private static void UpdateOrInsert(
Context context,
string loginId,
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 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));
Rds.ExecuteNonQuery(
context: context,
transactional: true,
statements: statements.ToArray());
}