private void InitPage()
{
var settings = SettingsMapper.GetSettings();
var rootMediaDetail = BaseMapper.GetDataModel().MediaDetails.FirstOrDefault(i => i.MediaType.Name == MediaTypeEnum.RootPage.ToString() && i.LanguageID == AdminBasePage.CurrentLanguage.ID);
if (rootMediaDetail == null)
{
CreateItem.Visible = true;
}
if (settings.EnableGlossaryTerms)
{
GlossaryTermsNavItem.Visible = true;
}
if (numberOfActiveLanguages < 2)
{
LanguageSwitcher.Visible = false;
}
else
{
LanguageSwitcher.Visible = true;
}
//AdminBasePage.SelectedMedia = null;
//AdminBasePage.SelectedMediaDetail = null;
CreateItem.NavigateUrl = $"{URIHelper.BaseUrl}Admin/Views/PageHandlers/Media/Create.aspx";
}
public IActionResult Settings(SettingsViewModel model)
{
var configuration = SettingsMapper.MapToConfiguration(model);
_configurationService.CreateWebhook(configuration);
return(RedirectToAction("Index"));
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (!canAccessSection)
{
return;
}
var settings = BaseMapper.GetObjectFromContext(SettingsMapper.GetSettings());
UpdateObjectFromFields(settings);
var returnObj = SettingsMapper.Update(settings);
if (returnObj.IsError)
{
DisplayErrorMessage("Error saving settings", returnObj.Error);
}
else
{
ContextHelper.ClearAllMemoryCache();
FileCacheHelper.ClearAllCache();
SettingsMapper.ClearCache();
DisplaySuccessMessage("Successfully saved settings");
}
}
protected void UploadFilesNow_Click(object sender, EventArgs e)
{
try
{
var field = GetField();
if (IsPostBack && Request.Files.Count > 0 && !hasRun)
{
hasRun = true;
var index = 0;
for (int i = 0; i < Request.Files.Count; i++)
{
var file = Request.Files[i];
if (string.IsNullOrEmpty(file.FileName))
{
continue;
}
var fileInfo = (new System.IO.FileInfo(GetFolderPath() + file.FileName));
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
if (fileInfo.Directory.Exists)
{
file.SaveAs(fileInfo.FullName);
var filePath = URIHelper.ConvertAbsUrlToTilda(URIHelper.ConvertAbsPathToAbsUrl(fileInfo.FullName)).Replace("~", "");
if (!field.FieldAssociations.Any(j => j.MediaDetail.PathToFile == filePath))
{
var fieldAssociation = new FieldAssociation();
fieldAssociation.MediaDetail = (MediaDetail)PagesMapper.CreateObject(MediaTypeID, MediasMapper.CreateObject(), AdminBasePage.SelectedMedia);
fieldAssociation.MediaDetail.LinkTitle = fieldAssociation.MediaDetail.SectionTitle = fieldAssociation.MediaDetail.ShortDescription = fieldAssociation.MediaDetail.MainContent = fileInfo.Name;
fieldAssociation.MediaDetail.PathToFile = filePath;
fieldAssociation.MediaDetail.PublishDate = DateTime.Now;
fieldAssociation.MediaDetail.CreatedByUser = fieldAssociation.MediaDetail.LastUpdatedByUser = FrameworkSettings.CurrentUser;
fieldAssociation.MediaDetail.CachedVirtualPath = fieldAssociation.MediaDetail.CalculatedVirtualPath();
fieldAssociation.MediaDetail.LanguageID = SettingsMapper.GetSettings().DefaultLanguage.ID;
field.FieldAssociations.Add(fieldAssociation);
index++;
var returnObj = BaseMapper.SaveDataModel();
}
}
}
}
SetValue(GetValue());
}
catch (Exception ex)
{
}
}
public ServerInfrastructureSettings GetInfrastructure()
{
_client.Executor.CheckApiServerVersion();
IRestRequest request = _client.Builder.GetInfrastructureSettings();
ApiInfrastructureSettings apiInfrastructureSettings =
_client.Executor.DoSyncApiCall <ApiInfrastructureSettings>(request, DracoonRequestExecutor.RequestType.GetInfrastructureSettings);
return(SettingsMapper.FromApiInfrastructureSettings(apiInfrastructureSettings));
}
public PasswordPolicies GetPasswordPolicies()
{
_client.Executor.CheckApiServerVersion(ApiConfig.ApiGetPasswordPoliciesMinimumVersion);
IRestRequest request = _client.Builder.GetPasswordPolicies();
ApiPasswordSettings apiPasswordPolicies =
_client.Executor.DoSyncApiCall <ApiPasswordSettings>(request, DracoonRequestExecutor.RequestType.GetPasswordPolicies);
return(SettingsMapper.FromApiPasswordPolicies(apiPasswordPolicies));
}
protected override void OnPreLoad(EventArgs e)
{
base.OnPreLoad(e);
if (IsPostBack)
{
return;
}
UpdateFieldsFromObject(SettingsMapper.GetSettings());
}
public void GetGlossaryTerms()
{
string response = "{}";
if (SettingsMapper.GetSettings().EnableGlossaryTerms)
{
response = JsonConvert.SerializeObject(GlossaryTermsMapper.GetAll());
}
WriteJSON(response);
}
public void FromApiInfrastructureSettings_Null()
{
// ARRANGE
ServerInfrastructureSettings expected = null;
ApiInfrastructureSettings param = null;
// ACT
ServerInfrastructureSettings actual = SettingsMapper.FromApiInfrastructureSettings(param);
// ASSERT
Assert.Equal(expected, actual, new ServerInfrastructureSettingsComparer());
}
protected void ShoppingCartList_OnDataBound(object sender, EventArgs e)
{
if (CurrentCart.Items.Count() == 0)
{
return;
}
Literal SubTotal = (Literal)ShoppingCartList.FindControl("SubTotal");
var ShoppingCartTax = (Literal)ShoppingCartList.FindControl("ShoppingCartTax");
Literal Total = (Literal)ShoppingCartList.FindControl("Total");
SubTotal.Text = CurrentCart.GetSubTotal().ToString();
Total.Text = CurrentCart.GetTotal().ToString();
ShoppingCartTax.Text = SettingsMapper.GetSettings().ShoppingCartTax.ToString();
}
public ApiAdapter(IDataBaseManagerFactory dbEngine, string address, string port, string table, string login, string password)
{
DbManager = new DatabaseManager(dbEngine, address, port, table, login, password);
DbConnector = new DbConnector(DbManager);
LanguageAdapter = new LanguageAdapter(DbConnector);
UserAdapter = new UserAdapter(DbConnector);
UserDetailsAdapter = new UserDetailsAdapter(DbConnector);
TransactionTypeAdapter = new TransactionTypeAdapter(DbConnector);
TransferTypeAdapter = new TransferTypeAdapter(DbConnector);
FrequencyAdapter = new FrequencyAdapter(DbConnector);
ImportanceAdapter = new ImportanceAdapter(DbConnector);
TagAdapter = new TagAdapter(DbConnector);
OperationAdapter = new OperationAdapter(DbConnector);
OperationDetailsAdapter = new OperationDetailsAdapter(DbConnector);
OperationTagRelationAdapter = new OperationTagAdapter(DbConnector);
OperationsGroupAdapter = new OperationsGroupAdapter(DbConnector);
OperationsGroupRelationAdapter = new OperationsGroupTagAdapter(DbConnector);
FilterAdapter = new FilterAdapter(DbConnector);
DashboardAdapter = new DashboardAdapter(DbConnector);
DashboardFilterRelationAdapter = new DashboardFilterRelationAdapter(DbConnector);
BankAdapter = new BankAdapter(DbConnector);
SettingsAdapter = new SettingsAdapter(DbConnector);
SchematicTypeAdapter = new SchematicTypeAdapter(DbConnector);
SchematicAdapter = new SchematicAdapter(DbConnector);
LanguageMapper = new LanguageMapper();
UserMapper = new UserMapper();
UserDetailsMapper = new UserDetailsMapper();
TransactionTypeMapper = new TransactionTypeMapper();
TransferTypeMapper = new TransferTypeMapper();
FrequencyMapper = new FrequencyMapper();
ImportanceMapper = new ImportanceMapper();
TagMapper = new TagMapper();
TagRelationMapper = new RelationTagMapper();
OperationMapper = new OperationMapper();
OperationsGroupMapper = new OperationsGroupMapper();
FilterMapper = new FilterMapper();
DashboardMapper = new DashboardMapper();
DashboardFilterMapper = new DashboardFilterMapper();
BankMapper = new BankMapper();
SettingsMapper = new SettingsMapper();
SchematicTypeMapper = new SchematicTypeMapper();
SchematicMapper = new SchematicMapper();
}
public void FromApiDefaultsSettings()
{
// ARRANGE
ServerDefaultSettings expected = FactoryServerSettings.ServerDefaultSettings;
ApiDefaultsSettings param = new ApiDefaultsSettings {
DownloadShareDefaultExpirationPeriodInDays = expected.DownloadShareDefaultExpirationPeriodInDays,
FileUploadDefaultExpirationPeriodInDays = expected.FileUploadDefaultExpirationPeriodInDays,
LanguageDefault = expected.LanguageDefault,
UploadShareDefaultExpirationPeriodInDays = expected.UploadShareDefaultExpirationPeriodInDays
};
// ACT
ServerDefaultSettings actual = SettingsMapper.FromApiDefaultsSettings(param);
// ASSERT
Assert.Equal(expected, actual, new ServerDefaultSettingsComparer());
}
public void FromApiInfrastructureSettings()
{
// ARRANGE
ServerInfrastructureSettings expected = FactoryServerSettings.ServerInfrastructureSettings;
ApiInfrastructureSettings param = new ApiInfrastructureSettings {
MediaServerConfigEnabled = expected.MediaServerConfigEnabled,
S3DefaultRegion = expected.S3DefaultRegion,
SmsConfigEnabled = expected.SmsConfigEnabled,
S3EnforceDirectUpload = expected.S3EnforceDirectUpload
};
// ACT
ServerInfrastructureSettings actual = SettingsMapper.FromApiInfrastructureSettings(param);
// ASSERT
Assert.Equal(expected, actual, new ServerInfrastructureSettingsComparer());
}
public void AlbumArtPopup()
{
var popupSettings = new AlbumArtPopupSettings
{
Width = 1,
Height = 2,
XPosition = 4,
IsVisible = true,
Margin = 10,
};
var model = SettingsMapper.ToModel <AlbumArtPopup>(popupSettings);
Assert.AreEqual(model.Width, popupSettings.Width);
Assert.AreEqual(model.Height, popupSettings.Height);
Assert.AreEqual(model.XPosition, popupSettings.XPosition);
Assert.AreEqual(model.IsVisible, popupSettings.IsVisible);
Assert.AreEqual(model.Margin, popupSettings.Margin);
}
public void GetGeneral()
{
// ARRANGE
ServerGeneralSettings expected = FactoryServerSettings.ServerGeneralSettings;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonServerSettingsImpl ss = new DracoonServerSettingsImpl(c);
Mock.Arrange(() => c.Builder.GetGeneralSettings()).Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0)).Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => SettingsMapper.FromApiGeneralSettings(Arg.IsAny <ApiGeneralSettings>())).Returns(FactoryServerSettings.ServerGeneralSettings).Occurs(1);
// ACT
ServerGeneralSettings actual = ss.GetGeneral();
// ASSERT
Assert.Equal(expected, actual, new ServerGeneralSettingsComparer());
Mock.Assert(() => SettingsMapper.FromApiGeneralSettings(Arg.IsAny <ApiGeneralSettings>()));
Mock.Assert(c.Executor);
Mock.Assert(c.Builder);
}
public void FromApiGeneralSettings()
{
// ARRANGE
ServerGeneralSettings expected = FactoryServerSettings.ServerGeneralSettings;
ApiGeneralSettings param = new ApiGeneralSettings {
CryptoEnabled = expected.CryptoEnabled,
EmailNotificationButtonEnabled = expected.EmailNotificationButtonEnabled,
EulaEnabled = expected.EulaEnabled,
MediaServerEnabled = expected.MediaServerEnabled,
SharePasswordSmsEnabled = expected.SharePasswordSmsEnabled,
UseS3Storage = expected.UseS3Storage,
WeakPasswordEnabled = expected.WeakPasswordEnabled
};
// ACT
ServerGeneralSettings actual = SettingsMapper.FromApiGeneralSettings(param);
// ASSERT
Assert.Equal(expected, actual, new ServerGeneralSettingsComparer());
}
public async Task <List <Settings> > GetSettings()
{
var mapper = new SettingsMapper();
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"GetJobOrderSettings",
new[]
{
typeof(Settings),
typeof(Log)
},
obj =>
{
Settings bs = obj[0] as Settings;
Log l = obj[1] as Log;
return mapper.Map(bs, l);
},
splitOn: "ID,LogID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).ToList());
}
public void SimpleTest()
{
var obj1 = SettingsMapper.Map <MySettings>();
var obj2 = new MySettings();
SettingsMapper.Map(obj2);
var obj3 = (MySettings)SettingsMapper.Map(typeof(MySettings), null);
var obj4 = new MySettings();
SettingsMapper.Map(obj4);
Assert.AreNotEqual(obj1, obj2);
Assert.AreNotEqual(obj1, obj3);
Assert.AreNotEqual(obj1, obj4);
Check(obj1);
Check(obj2);
Check(obj3);
Check(obj4);
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (selectedItem == null)
{
selectedItem = MasterPagesMapper.CreateObject();
}
else
{
selectedItem = BaseMapper.GetObjectFromContext <MasterPage>(selectedItem);
}
UpdateObjectFromFields();
Return returnObj = selectedItem.Validate();
if (!returnObj.IsError)
{
if (selectedItem.ID == 0)
{
returnObj = MasterPagesMapper.Insert(selectedItem);
}
else
{
returnObj = MasterPagesMapper.Update(selectedItem);
}
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
SettingsMapper.ClearCache();
DisplaySuccessMessage("Successfully Saved Item");
}
}
public static Settings GetSettings()
{
return(SettingsMapper.GetSettings());
}
public void ConfigureSettings(IContainer container)
{
var settings = SettingsMapper.Map <SiteSettings>();
container.Configure(config => config.For <SiteSettings>().Singleton().Use(settings));
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
RedisCacheHelper.SetRedisCacheConnectionString(AppSettings.RedisCacheConnectionString);
FileCacheHelper.SetFileSystemCacheDirPath(AppSettings.FileSystemCacheDirPath);
virtualPath = URIHelper.GetCurrentVirtualPath().ToLower();
var queryString = HttpContext.Current.Request.QueryString.ToString();
queryString = System.Web.HttpUtility.UrlDecode(queryString);
if (!Request.Path.EndsWith("/") || ((virtualPath != "~/") && (!virtualPath.EndsWith("/"))))
{
var path = Request.Path + "/";
if (!string.IsNullOrEmpty(queryString))
{
path = path + "?" + queryString;
}
HttpContext.Current.Response.RedirectPermanent(path);
}
Settings cmsSettings = null;
bool isAttemptingAdminLogin = false;
if ((virtualPath != "~/login/") && (virtualPath != "~/admin/") && string.IsNullOrEmpty(Request.QueryString["format"]))
{
cmsSettings = SettingsMapper.GetSettings();
if (cmsSettings != null)
{
var isSiteOnline = cmsSettings.IsSiteOnline();
if (isSiteOnline)
{
if (virtualPath.Contains(cmsSettings.SiteOfflineUrl))
{
Response.Redirect("~/");
}
AttemptToLoadFromCache();
}
else
{
if (!virtualPath.Contains(cmsSettings.SiteOfflineUrl))
{
Response.Redirect(cmsSettings.SiteOfflineUrl);
}
}
}
else
{
AttemptToLoadFromCache();
}
}
else
{
isAttemptingAdminLogin = true;
}
var languageSegment = FrameworkSettings.GetCurrentLanguage().UriSegment;
if (LanguagesMapper.GetAllActive().Count() > 1 && !Request.Url.PathAndQuery.Contains($"/{languageSegment}/"))
{
var url = URIHelper.ConvertToAbsUrl("/" + languageSegment + Request.Url.PathAndQuery);
Response.RedirectPermanent(url, true);
}
var segments = URIHelper.GetUriSegments(virtualPath).ToList();
string firstSegment = "";
if (segments.Count > 0)
{
firstSegment = segments[0];
var language = LanguagesMapper.GetAllActive().SingleOrDefault(i => i.UriSegment == firstSegment);
if (language != null)
{
FrameworkSettings.SetCurrentLanguage(language);
}
}
if (!isAttemptingAdminLogin && AppSettings.EnableUrlRedirectRules)
{
var path = virtualPath;
if (!string.IsNullOrEmpty(queryString))
{
path = path + "?" + queryString;
}
var redirectRule = UrlRedirectRulesMapper.GetRuleForUrl(path);
if (redirectRule != null)
{
var newUrl = redirectRule.RedirectToUrl;
if (newUrl.Contains("{"))
{
newUrl = MediaDetailsMapper.ParseSpecialTags(redirectRule, newUrl);
}
newUrl = URIHelper.ConvertToAbsUrl(newUrl);
var possibleLoopRules = UrlRedirectRulesMapper.GetRulesFromUrl(URIHelper.ConvertAbsUrlToTilda(newUrl));
var foundActiveVirtualPath = MediaDetailsMapper.GetByVirtualPath(path);
if (possibleLoopRules.Any())
{
foreach (var rule in possibleLoopRules)
{
var returnObj = MediaDetailsMapper.DeletePermanently(rule);
}
}
if (foundActiveVirtualPath != null)
{
var returnObj = MediaDetailsMapper.DeletePermanently(redirectRule);
}
if (Request.QueryString.Count > 0)
{
newUrl += "?" + Request.QueryString;
}
if (redirectRule.Is301Redirect)
{
Response.RedirectPermanent(newUrl);
}
else
{
Response.Redirect(newUrl);
}
}
}
if (!File.Exists(HttpContext.Current.Server.MapPath(virtualPath)) && !virtualPath.Contains(ParserHelper.OpenToken) && !virtualPath.Contains(ParserHelper.CloseToken))
{
string viewPath = "";
long mediaDetailId = 0;
long.TryParse(requestContext.HttpContext.Request["MediaDetailID"], out mediaDetailId);
long mediaId = 0;
long.TryParse(requestContext.HttpContext.Request["MediaID"], out mediaId);
MediaDetail detail = null;
if (mediaDetailId == 0 && mediaId == 0)
{
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByVirtualPath(virtualPath, true);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
else if (mediaDetailId != 0)
{
var mediaDetail = MediaDetailsMapper.GetByID(mediaDetailId);
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMediaDetail(mediaDetail);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
else if (mediaId != 0)
{
var media = MediasMapper.GetByID(mediaId);
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMedia(media);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
/*if (detail != null && !detail.CanUserAccessSection(FrameworkSettings.CurrentUser))
* {
* FormsAuthentication.RedirectToLoginPage();
* }*/
/*if (detail != null)
* {
* var absUrlBase = URIHelper.ConvertAbsUrlToTilda(detail.AbsoluteUrl).Replace("~", "");
* var absPathBase = URIHelper.ConvertAbsUrlToTilda(Request.Url.AbsolutePath).Replace("~", "");
*
* if (absUrlBase != absPathBase)
* {
* Response.Redirect(detail.AbsoluteUrl + Request.Url.Query);
* }
* }*/
if (detail != null)
{
if (detail.ForceSSL || AppSettings.ForceSSL)
{
URIHelper.ForceSSL();
}
}
else
{
var currentLanguageId = FrameworkSettings.GetCurrentLanguage().ID;
var historyVersion = BaseMapper.GetDataModel().MediaDetails.FirstOrDefault(i => i.LanguageID == currentLanguageId && i.CachedVirtualPath == virtualPath && i.MediaType.ShowInSiteTree && i.HistoryVersionNumber != 0 && i.HistoryForMediaDetail != null);
if (historyVersion != null && historyVersion.VirtualPath != historyVersion.HistoryForMediaDetail.VirtualPath)
{
var foundRedirectUrl = UrlRedirectRulesMapper.GetRuleForUrl(virtualPath);
if (foundRedirectUrl == null)
{
var urlRedirectRule = UrlRedirectRulesMapper.CreateUrlRedirect(virtualPath, historyVersion.HistoryForMediaDetail.Media);
if (urlRedirectRule != null)
{
var returnObj = UrlRedirectRulesMapper.Insert(urlRedirectRule);
HttpContext.Current.Response.RedirectPermanent(historyVersion.HistoryForMediaDetail.CachedVirtualPath);
}
else
{
HttpContext.Current.Response.RedirectPermanent("/");
}
}
}
else
{
HttpContext.Current.Response.RedirectPermanent("/");
}
}
if ((detail == null) || (!IsValidRequest(detail)))
{
detail = null;
if (cmsSettings != null)
{
if (!string.IsNullOrEmpty(cmsSettings.PageNotFoundUrl))
{
ErrorHelper.LogException(new Exception($"Page Not Found: {virtualPath}"));
Response.Redirect(cmsSettings.PageNotFoundUrl);
/*FrameworkSettings.CurrentFrameworkBaseMedia = null;
*
* FrameworkSettings.CurrentFrameworkBaseMedia = FrameworkBaseMedia.GetInstanceByVirtualPath(cmsSettings.PageNotFoundUrl, true);
* detail = (MediaDetail)FrameworkSettings.CurrentFrameworkBaseMedia.CurrentMediaDetail;
*
* ErrorHelper.LogException(new Exception($"Page Not Found: {virtualPath}"));*/
//Response.StatusCode = 301;
}
}
}
if (detail != null)
{
var draft = detail.GetLatestDraft();
if (draft != null && (draft.PublishDate - detail.PublishDate) > TimeSpan.FromSeconds(10) && draft.CanRender)
{
var returnObj = draft.PublishLive();
if (!returnObj.IsError)
{
detail.RemoveFromCache();
draft.RemoveFromCache();
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMediaDetail(draft);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
}
if (detail.RedirectToFirstChild)
{
var child = detail.ChildMediaDetails.FirstOrDefault();
if (child != null)
{
var redirectPath = child.AutoCalculatedVirtualPath;
if (!string.IsNullOrEmpty(queryString))
{
redirectPath = redirectPath + "?" + queryString;
}
HttpContext.Current.Response.Redirect(redirectPath);
}
}
viewPath = FrameworkSettings.Current.CurrentMediaDetail.Handler;
if ((viewPath == null) || (viewPath.Trim() == ""))
{
viewPath = MediaTypesMapper.GetByID(FrameworkSettings.Current.CurrentMediaDetail.MediaTypeID).MediaTypeHandler;
}
viewPath = URIHelper.ConvertAbsUrlToTilda(viewPath);
if (!string.IsNullOrEmpty(Request.QueryString["format"]))
{
FrontEndBasePage.HandleFormatQueryString(detail, Request.QueryString["format"], Request.QueryString["depth"]);
}
return(CreateInstanceFromVirtualPath(viewPath, typeof(BasePage)));
}
}
return(new DefaultHttpHandler());
}
public ApiSettings GetSettings(ApiUser user)
{
SettingsMapper.Update(user);
return(SettingsMapper.ConvertToApiEntitiesCollection(SettingsAdapter.GetAll($"user_id={user.Id}")).LastOrDefault());
}
