public void AddResource(string key, object value)
{
Verify.ArgumentNotNullOrEmpty(key, nameof(key));
Verify.ArgumentNotNull(value, nameof(value));
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
var resourceKey = data.Get <IResourceKey>().SingleOrDefault(k => Equals(k.ResourceSet, _resourceSet) && k.Key == key);
if (resourceKey == null)
{
resourceKey = data.CreateNew <IResourceKey>();
resourceKey.Id = Guid.NewGuid();
resourceKey.Key = key;
resourceKey.ResourceSet = _resourceSet;
data.Add(resourceKey);
}
var resourceValue = data.CreateNew <IResourceValue>();
resourceValue.Id = Guid.NewGuid();
resourceValue.KeyId = resourceKey.Id;
resourceValue.Culture = _cultureName;
resourceValue.Value = value.ToString();
data.Add(resourceValue);
}
transaction.Complete();
}
}
public static void CopyNamespace(string ns, string newNs, string resourceSet)
{
Verify.ArgumentNotNull(ns, "ns");
Verify.ArgumentNotNull(newNs, "newNs");
if (resourceSet == String.Empty)
{
resourceSet = null;
}
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
var keysToAdd = new List <IResourceKey>();
var valuesToAdd = new List <IResourceValue>();
var resources = (from key in data.Get <IResourceKey>()
join value in data.Get <IResourceValue>() on key.Id equals value.KeyId into values
where key.ResourceSet == resourceSet && key.Key.StartsWith(ns + ".")
select new
{
Key = key,
Values = values
}).ToList();
foreach (var resource in resources)
{
var keyToAdd = data.CreateNew <IResourceKey>();
keyToAdd.Id = Guid.NewGuid();
keyToAdd.Key = resource.Key.Key.Remove(0, ns.Length).Insert(0, newNs);
keyToAdd.ResourceSet = resource.Key.ResourceSet;
keyToAdd.Type = resource.Key.Type;
keysToAdd.Add(keyToAdd);
foreach (var value in resource.Values)
{
var valueToAdd = data.CreateNew <IResourceValue>();
valueToAdd.Id = Guid.NewGuid();
valueToAdd.KeyId = keyToAdd.Id;
valueToAdd.Culture = value.Culture;
valueToAdd.Value = value.Value;
valuesToAdd.Add(valueToAdd);
}
}
data.Add <IResourceKey>(keysToAdd);
data.Add <IResourceValue>(valuesToAdd);
}
transaction.Complete();
}
}
private static void MoveDataFromIUserToIUserFormLogin()
{
using (var conn = new DataConnection())
{
var users = conn.Get <IUser>().ToList();
var existingUserLogins = new HashSet <Guid>(conn.Get <IUserFormLogin>().Select(l => l.UserId));
foreach (var user in users.Where(u => !existingUserLogins.Contains(u.Id)))
{
if (string.IsNullOrEmpty(user.PasswordHashSalt) && !string.IsNullOrEmpty(user.EncryptedPassword))
{
throw new InvalidOperationException("User password stored in old format");
}
var userFormLogin = DataConnection.New <IUserFormLogin>();
userFormLogin.UserId = user.Id;
userFormLogin.Folder = user.Group;
userFormLogin.IsLocked = user.IsLocked;
userFormLogin.LockoutReason = user.LockoutReason;
userFormLogin.PasswordHash = user.EncryptedPassword;
userFormLogin.PasswordHashSalt = user.PasswordHashSalt;
conn.Add(userFormLogin);
// Clear out old data
user.IsLocked = false;
user.LockoutReason = 0;
user.Group = null;
user.EncryptedPassword = null;
user.PasswordHashSalt = null;
conn.Update(user);
}
}
}
public string Rate(string score, string ratyId)
{
Guid ratyGuid = Guid.Parse(ratyId);
using (DataConnection conn = new DataConnection())
{
var ratyItem = conn.Get <Results>().Where(r => r.RatyId == ratyGuid).SingleOrDefault();
if (ratyItem != null)
{
ratyItem.Count += 1;
ratyItem.TotalValue = ratyItem.TotalValue + decimal.Parse(score, System.Globalization.CultureInfo.InvariantCulture);
conn.Update <Results>(ratyItem);
}
else
{
ratyItem = conn.CreateNew <Results>();
ratyItem.RatyId = ratyGuid;
ratyItem.Count = 1;
ratyItem.TotalValue = decimal.Parse(score, System.Globalization.CultureInfo.InvariantCulture);
conn.Add <Results>(ratyItem);
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
var data = new { TotalValue = ratyItem.TotalValue, Count = ratyItem.Count };
SetCookie(ratyId);
return(serializer.Serialize(data));
}
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
var token = (ToggleFunctionRouteActionToken)actionToken;
using (var data = new DataConnection())
{
var route = data.Get <IFunctionRoute>().SingleOrDefault(r => r.Function == token.Function);
if (route == null)
{
route = data.CreateNew <IFunctionRoute>();
route.Id = Guid.NewGuid();
route.Function = token.Function;
data.Add(route);
}
else
{
data.Delete(route);
}
}
var treeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
treeRefresher.PostRefreshMesseges(entityToken);
return(null);
}
public Kobelco.ContactRequest SaveContactUsRequest(ContactRequestDTO dto)
{
using (var c = new DataConnection())
{
var entity = c.CreateNew <Kobelco.ContactRequest>();
entity.Id = Guid.NewGuid();
entity.DateSubmitted = DateTime.Now;
entity.FirstName = dto.FirstName;
entity.LastName = dto.LastName;
entity.Email = dto.Email;
entity.Phone = dto.Phone;
entity.Company = dto.Company;
entity.Address = dto.Address;
entity.City = dto.City;
entity.State = dto.State;
entity.Zip = dto.Zip;
entity.InquiryType = dto.InquiryType;
entity.Product = dto.Product;
entity.SerialNumber = dto.SerialNumber;
entity.Message = dto.Comments;
c.Add(entity);
return(entity);
}
}
public static IShopOrder CreateNewOrder(OrderCreationSettings settings)
{
if (OrderProcessor == null)
{
throw new InvalidOperationException("No order processor present, can't generate a new orderid");
}
var orderId = OrderProcessor.GenerateNextOrderId(settings);
using (var data = new DataConnection())
{
var order = data.CreateNew <IShopOrder>();
order.Id = orderId;
order.CreatedOn = DateTime.UtcNow;
order.OrderTotal = settings.TotalAmount;
order.Currency = settings.Currency.ToString();
order.CustomData = settings.CustomData;
order = data.Add(order);
order.WriteLog("created");
return(order);
}
}
public string Rate(string score, string ratyId)
{
Guid ratyGuid = Guid.Parse(ratyId);
using (DataConnection conn = new DataConnection())
{
var ratyItem = conn.Get<Results>().Where(r => r.RatyId == ratyGuid).SingleOrDefault();
if (ratyItem != null)
{
ratyItem.Count += 1;
ratyItem.TotalValue = ratyItem.TotalValue + decimal.Parse(score, System.Globalization.CultureInfo.InvariantCulture);
conn.Update<Results>(ratyItem);
}
else
{
ratyItem = conn.CreateNew<Results>();
ratyItem.RatyId = ratyGuid;
ratyItem.Count = 1;
ratyItem.TotalValue = decimal.Parse(score, System.Globalization.CultureInfo.InvariantCulture);
conn.Add<Results>(ratyItem);
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
var data = new { TotalValue = ratyItem.TotalValue, Count = ratyItem.Count };
SetCookie(ratyId);
return serializer.Serialize(data);
}
}
public override void OnFinish(object sender, EventArgs e)
{
var resourceSet = GetBinding <string>("ResourceSet");
var key = GetBinding <string>("Key");
var type = GetBinding <string>("Type");
using (var data = new DataConnection())
{
var resourceKey = data.CreateNew <IResourceKey>();
resourceKey.Id = Guid.NewGuid();
resourceKey.ResourceSet = String.IsNullOrEmpty(resourceSet) ? null : resourceSet;
resourceKey.Key = key;
resourceKey.Type = type;
resourceKey = data.Add(resourceKey);
var newResourceEntityToken = resourceKey.GetDataEntityToken();
var treeRefresher = CreateAddNewTreeRefresher(EntityToken);
treeRefresher.PostRefreshMesseges(newResourceEntityToken);
ExecuteWorklow(newResourceEntityToken, typeof(EditResourceWorkflow));
}
}
public override void OnFinish(object sender, EventArgs e)
{
var name = GetBinding <string>("Name");
var includeAttachments = GetBinding <bool>("IncludeAttachments");
var from = GetBinding <string>("From");
var to = GetBinding <string>("To");
var cc = GetBinding <string>("Cc");
var bcc = GetBinding <string>("Bcc");
var subject = GetBinding <string>("Subject");
var body = GetBinding <string>("Body");
var encryptMessage = GetBinding <bool>("EncryptMessage");
var encryptPassword = GetBinding <string>("EncryptPassword");
var definition = GetDefinition();
var handler = GetHandler();
var existingHandler = definition.SubmitHandlers.Single(h => h.Name == handler.Name);
handler.Name = name;
handler.IncludeAttachments = includeAttachments;
using (var data = new DataConnection())
{
var templateKey = definition.Name + "." + handler.Name;
var template = data.Get <IMailTemplate>().SingleOrDefault(t => t.Key == templateKey) ?? data.CreateNew <IMailTemplate>();
template.Key = templateKey;
template.From = from;
template.To = to;
template.Cc = cc;
template.Bcc = bcc;
template.EncryptMessage = encryptMessage;
template.EncryptPassword = encryptPassword;
if (template.DataSourceId.ExistsInStore)
{
data.Update(template);
}
else
{
data.Add(template);
}
var templateContent = template.GetContent();
templateContent.Subject = subject;
templateContent.Body = body;
data.Update(templateContent);
}
definition.SubmitHandlers.Remove(existingHandler);
definition.SubmitHandlers.Add(handler);
DefinitionsFacade.Save(definition);
CreateSpecificTreeRefresher().PostRefreshMessages(EntityToken);
SetSaveStatus(true);
}
// Adding a new product
public Product PostProduct(Product product)
{
using (var c = new DataConnection())
{
product.Id = Guid.NewGuid();
return c.Add(product);
}
}
public DataUpdateCompareResult <T> DataUpdate(bool allowDelete = true)
{
using (var data = new DataConnection())
{
var existingItems = data.Get <T>().ToDictionary(i => new DataMultiPartKey(i));
var newItems = new List <T>();
var updateItems = new List <T>();
foreach (var itemToCompare in _list)
{
_cancellationToken.ThrowIfCancellationRequested();
var key = new DataMultiPartKey(itemToCompare);
T existingItem;
if (existingItems.TryGetValue(key, out existingItem))
{
existingItems.Remove(key);
if (!PublicInstancePropertiesUpdateCompare(existingItem, itemToCompare))
{
updateItems.Add(existingItem);
}
}
else
{
newItems.Add(itemToCompare);
}
}
if (existingItems.Values.Count > 0 && allowDelete)
{
ClearForeignKeyFields(existingItems.Values, data);
_logger.AppendToLog("Deleting {0} items", existingItems.Values.Count);
data.Delete <T>(existingItems.Values);
}
if (newItems.Count > 0)
{
_logger.AppendToLog("Adding {0} items", newItems.Count);
data.Add <T>(newItems);
}
if (updateItems.Count > 0)
{
_logger.AppendToLog("Updating {0} items", updateItems.Count);
data.Update <T>(updateItems);
}
return(new DataUpdateCompareResult <T>(newItems, updateItems, existingItems.Values));
}
}
public override void OnFinish(object sender, EventArgs e)
{
var key = GetBinding <string>("Key");
var type = GetBinding <string>("Type");
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
if (key != ResourceKey.Key || type != ResourceKey.Type)
{
ResourceKey.Key = key;
ResourceKey.Type = type;
data.Update(ResourceKey);
var treeRefresher = CreateSpecificTreeRefresher();
treeRefresher.PostRefreshMesseges(new LocalizationElementProviderEntityToken());
}
var resourceValues = data.Get <IResourceValue>().Where(v => v.KeyId == ResourceKey.Id).ToDictionary(v => v.Culture);
foreach (var culture in DataLocalizationFacade.ActiveLocalizationCultures)
{
var bindingKey = GetBindingKey(culture);
var value = GetBinding <string>(bindingKey);
IResourceValue resourceValue;
if (resourceValues.TryGetValue(culture.Name, out resourceValue))
{
resourceValue.Value = value;
data.Update(resourceValue);
}
else
{
resourceValue = data.CreateNew <IResourceValue>();
resourceValue.Id = Guid.NewGuid();
resourceValue.KeyId = ResourceKey.Id;
resourceValue.Culture = culture.Name;
resourceValue.Value = value;
data.Add(resourceValue);
}
}
}
transaction.Complete();
}
SetSaveStatus(true);
}
public ImportResult Import()
{
_keysToAdd.Clear();
_valuesToAdd.Clear();
_valuesToUpdate.Clear();
var result = new ImportResult
{
Languages = _model.Languages.Keys.ToArray(),
ResourceSets = _model.Languages.Values.SelectMany(l => l.ResourceSets.Select(r => r.Name)).Distinct().ToArray()
};
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
var existingKeys = data.Get<IResourceKey>().ToDictionary(k => k.Key);
var existingValues = data.Get<IResourceValue>().ToDictionary(v => Tuple.Create(v.KeyId, v.Culture));
foreach (var language in _model.Languages.Values)
{
foreach (var resourceSet in language.ResourceSets)
{
EvaluateAddOrUpdates(language.Culture, resourceSet, data, result, existingKeys, existingValues);
}
}
result.KeysAdded = _keysToAdd.Count;
result.ValuesAdded = _valuesToAdd.Count;
result.ValuesUpdated = _valuesToUpdate.Count;
data.Add<IResourceKey>(_keysToAdd);
data.Add<IResourceValue>(_valuesToAdd);
data.Update<IResourceValue>(_valuesToUpdate);
}
transaction.Complete();
}
return result;
}
private static void Upgrade()
{
var defaultCurrency = ECommerceSection.GetSection().DefaultCurrency;
using (var data = new DataConnection())
{
var update = new List <IShopOrder>();
var orders = data.Get <IShopOrder>().Where(o => o.Currency == null || o.Currency.Length == 0).ToList();
foreach (var order in orders)
{
order.Currency = defaultCurrency.ToString();
update.Add(order);
}
data.Update <IShopOrder>(update);
orders = data.Get <IShopOrder>().Where(o => o.AuthorizationXml != null || o.AuthorizationTransactionId != null || o.CreditCardType != null).ToList();
foreach (var order in orders)
{
var paymentRequest = data.Get <IPaymentRequest>().SingleOrDefault(p => p.ShopOrderId == order.Id);
if (paymentRequest == null)
{
paymentRequest = data.CreateNew <IPaymentRequest>();
paymentRequest.ShopOrderId = order.Id;
}
paymentRequest.ProviderName = ECommerceSection.GetSection().DefaultProvider;
paymentRequest.AuthorizationData = order.AuthorizationXml;
paymentRequest.AuthorizationTransactionId = order.AuthorizationTransactionId;
paymentRequest.PaymentMethod = order.CreditCardType;
paymentRequest.Accepted = (PaymentStatus)order.PaymentStatus == PaymentStatus.Authorized;
if (paymentRequest.DataSourceId.ExistsInStore)
{
data.Update(paymentRequest);
}
else
{
data.Add(paymentRequest);
}
order.AuthorizationXml = null;
order.AuthorizationTransactionId = null;
order.CreditCardType = null;
update.Add(order);
}
data.Update <IShopOrder>(update);
}
}
public static void CreateNewTemplate(Guid gTemplateGuid, string sTitle)
{
using (DataConnection connection = new DataConnection())
{
IXmlPageTemplate data = DataConnection.New<IXmlPageTemplate>();
data.Id = gTemplateGuid;
data.Title = sTitle;
data.PageTemplateFilePath = String.Format("/{0}.xml", sTitle);
connection.Add<IXmlPageTemplate>(data);
}
}
public override void OnFinish(object sender, EventArgs e)
{
var favoriteFunction = GetBinding <IFavoriteFunction>("FavoriteFunction");
using (var data = new DataConnection())
{
data.Add(favoriteFunction);
}
var treeRefresher = CreateParentTreeRefresher();
treeRefresher.PostRefreshMesseges(EntityToken);
}
public static T AddOrUpdate <T>(this DataConnection data, T itm) where T : class, IData
{
if (itm.DataSourceId.ExistsInStore)
{
data.Update(itm);
}
else
{
itm = data.Add(itm);
}
return(itm);
}
public static XhtmlDocument SaveBrokenLink()
{
var request = HttpContext.Current.Request;
// ignore if referer is empty
if (request.UrlReferrer == null ||
request.RawUrl.StartsWith("/Composite/content/flow/FlowUi.aspx", StringComparison.InvariantCultureIgnoreCase) ||
request.UrlReferrer.ToString().IndexOf("/Composite/content/views/browser/browser.aspx", StringComparison.InvariantCultureIgnoreCase) > 0)
{
return(null);
}
var url = "http://" + request.Url.Host + request.RawUrl;
using (var dataConnection = new DataConnection())
{
var sitemapNavigator = new SitemapNavigator(dataConnection);
if (sitemapNavigator.CurrentPageNode != null && request.RawUrl.Equals(sitemapNavigator.CurrentPageNode.Url))
{
return(null);
}
}
var referer = (request.UrlReferrer == null) ? "" : request.UrlReferrer.ToString();
var userAgent = request.UserAgent ?? string.Empty;
var ipAddress = GetIPAddress(request);
if (!UserAgentIsTrusted(userAgent) ||
!RefererIsTrusted(referer) ||
IPAddressIsInBlackList(ipAddress))
{
return(null);
}
using (var conn = new DataConnection())
{
var item = conn.Get <BrokenLink>().FirstOrDefault(el => el.BadURL == url);
if (item == null)
{
var newItem = conn.CreateNew <BrokenLink>();
newItem.Id = Guid.NewGuid();
newItem.BadURL = url;
newItem.Referer = referer;
newItem.UserAgent = userAgent;
newItem.IP = ipAddress;
newItem.Date = DateTime.Now;
conn.Add <BrokenLink>(newItem);
}
}
return(null);
}
public static void CreatePaymentRequest(this IShopOrder order, string provider)
{
Verify.ArgumentCondition(ECommerce.Providers.ContainsKey(provider), "provider", String.Format("Provider '{0}' doesn't exist", provider));
using (var data = new DataConnection())
{
var request = data.CreateNew <IPaymentRequest>();
request.ShopOrderId = order.Id;
request.ProviderName = provider;
request.Accepted = false;
data.Add(request);
}
}
public static IShopOrderLog WriteLog(this IShopOrder order, string logTitle, string logData)
{
using (var data = new DataConnection())
{
var entry = data.CreateNew <IShopOrderLog>();
entry.Id = Guid.NewGuid();
entry.ShopOrderId = order.Id;
entry.Timestamp = DateTime.UtcNow;
entry.Title = logTitle;
entry.Data = logData;
return(data.Add(entry));
}
}
public static XhtmlDocument SaveBrokenLink()
{
var request = HttpContext.Current.Request;
// ignore if referer is empty
if (request.UrlReferrer == null
|| request.RawUrl.StartsWith("/Composite/content/flow/FlowUi.aspx", StringComparison.InvariantCultureIgnoreCase)
|| request.UrlReferrer.ToString().IndexOf("/Composite/content/views/browser/browser.aspx", StringComparison.InvariantCultureIgnoreCase) > 0)
{
return null;
}
var url = "http://" + request.Url.Host + request.RawUrl;
using (var dataConnection = new DataConnection())
{
var sitemapNavigator = new SitemapNavigator(dataConnection);
if (sitemapNavigator.CurrentPageNode != null && request.RawUrl.Equals(sitemapNavigator.CurrentPageNode.Url))
return null;
}
var referer = (request.UrlReferrer == null) ? "" : request.UrlReferrer.ToString();
var userAgent = request.UserAgent ?? string.Empty;
var ipAddress = GetIPAddress(request);
if (!UserAgentIsTrusted(userAgent)
|| !RefererIsTrusted(referer)
|| IPAddressIsInBlackList(ipAddress))
{
return null;
}
using (var conn = new DataConnection())
{
var item = conn.Get<BrokenLink>().FirstOrDefault(el => el.BadURL == url);
if (item == null)
{
var newItem = conn.CreateNew<BrokenLink>();
newItem.Id = Guid.NewGuid();
newItem.BadURL = url;
newItem.Referer = referer;
newItem.UserAgent = userAgent;
newItem.IP = ipAddress;
newItem.Date = DateTime.Now;
conn.Add<BrokenLink>(newItem);
}
}
return null;
}
public string SavePageContent(string pageId, string placeholderId, string content)
{
Guid pageGuid = Guid.Parse(pageId);
string contentHtml = HttpUtility.UrlDecode(content);
contentHtml = HttpUtility.HtmlDecode(contentHtml.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;"));
string xhtmlDocumentWrapper = string.Format("<html xmlns='http://www.w3.org/1999/xhtml'><head></head><body>{0}</body></html>", contentHtml);
XElement xElement = XElement.Parse(xhtmlDocumentWrapper);
RemoveInvalidElements(xElement);
contentHtml = string.Concat((xElement.Elements().Select(b => b.ToString())).ToArray());
foreach (PublicationScope scope in Enum.GetValues(typeof(PublicationScope)))
{
using (DataConnection connection = new DataConnection(scope))
{
var phHolder = Composite.Data.PageManager.GetPlaceholderContent(pageGuid).Where(ph => ph.PlaceHolderId == placeholderId).SingleOrDefault();
if (phHolder != null)
{
phHolder.Content = contentHtml;
connection.Update <IPagePlaceholderContent>(phHolder);
}
else
{
var page = connection.Get <IPage>().Where(p => p.Id == pageGuid).SingleOrDefault();
var templateInfo = TemplateInfo.GetRenderingPlaceHolders(page.TemplateId);
foreach (var ph in templateInfo.Placeholders)
{
if (ph.Key == placeholderId)
{
IPagePlaceholderContent newPh = connection.CreateNew <IPagePlaceholderContent>();
newPh.PageId = pageGuid;
newPh.PlaceHolderId = placeholderId;
newPh.Content = contentHtml;
connection.Add <IPagePlaceholderContent>(newPh);
}
}
}
}
}
return("Success");
}
public string SavePageContent(string pageId, string placeholderId, string content)
{
Guid pageGuid = Guid.Parse(pageId);
string contentHtml = HttpUtility.UrlDecode(content);
contentHtml = HttpUtility.HtmlDecode(contentHtml.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;"));
string xhtmlDocumentWrapper = string.Format("<html xmlns='http://www.w3.org/1999/xhtml'><head></head><body>{0}</body></html>", contentHtml);
XElement xElement = XElement.Parse(xhtmlDocumentWrapper);
RemoveInvalidElements(xElement);
contentHtml = string.Concat((xElement.Elements().Select(b => b.ToString())).ToArray());
foreach (PublicationScope scope in Enum.GetValues(typeof(PublicationScope)))
{
using (DataConnection connection = new DataConnection(scope))
{
var phHolder = Composite.Data.PageManager.GetPlaceholderContent(pageGuid).Where(ph => ph.PlaceHolderId == placeholderId).SingleOrDefault();
if (phHolder != null)
{
phHolder.Content = contentHtml;
connection.Update<IPagePlaceholderContent>(phHolder);
}
else
{
var page = connection.Get<IPage>().Where(p => p.Id == pageGuid).SingleOrDefault();
var templateInfo = TemplateInfo.GetRenderingPlaceHolders(page.TemplateId);
foreach (var ph in templateInfo.Placeholders)
{
if (ph.Key == placeholderId)
{
IPagePlaceholderContent newPh = connection.CreateNew<IPagePlaceholderContent>();
newPh.PageId = pageGuid;
newPh.PlaceHolderId = placeholderId;
newPh.Content = contentHtml;
connection.Add<IPagePlaceholderContent>(newPh);
}
}
}
}
}
return "Success";
}
public static IPaymentRequest CreatePaymentRequest(this IShopOrder order, CreatePaymentRequestOptions options)
{
var provider = options.Provider;
Verify.ArgumentCondition(ECommerce.Providers.ContainsKey(provider), nameof(provider), $"Provider '{provider}' doesn't exist");
using (var data = new DataConnection())
{
var request = data.CreateNew <IPaymentRequest>();
request.ShopOrderId = order.Id;
request.ProviderName = provider;
request.Accepted = false;
request.CancelUrl = options.CancelUrl;
request = data.Add(request);
return(request);
}
}
public override void OnInitialize(object sender, EventArgs e)
{
if (BindingExist("Name"))
{
return;
}
var definition = GetDefinition();
var handler = GetHandler();
using (var data = new DataConnection())
{
var key = definition.Name + "." + handler.Name;
var template = data.Get <IMailTemplate>().SingleOrDefault(t => t.Key == key);
if (template == null)
{
template = data.CreateNew <IMailTemplate>();
template.Key = key;
template = data.Add(template);
}
var content = template.GetContent();
Bindings.Add("Name", handler.Name);
Bindings.Add("IncludeAttachments", handler.IncludeAttachments);
Bindings.Add("From", template.From);
Bindings.Add("To", template.To);
Bindings.Add("Cc", template.Cc);
Bindings.Add("Bcc", template.Bcc);
Bindings.Add("Subject", content.Subject);
Bindings.Add("Body", content.Body);
Bindings.Add("EncryptMessage", template.EncryptMessage);
Bindings.Add("EncryptPassword", template.EncryptPassword);
}
}
public ActionResult UploadFile(EbookFileUploadViewModel viewModel)
{
if (Request.Files.Count != 1 || Request.Files[0].ContentLength == 0)
{
ModelState.AddModelError("uploadError", "File's length is zero, or no files found");
return(View(viewModel));
}
// check the file size (max 4 Mb)
if (Request.Files[0].ContentLength > 1024 * 1024 * 4)
{
ModelState.AddModelError("uploadError", "File size can't exceed 4 MB");
return(View(viewModel));
}
// check the file size (min 100 bytes)
if (Request.Files[0].ContentLength < 100)
{
ModelState.AddModelError("uploadError", "File size is too small");
return(View(viewModel));
}
// check file extension
string extension = Path.GetExtension(Request.Files[0].FileName).ToLower();
if (extension != ".epub")
{
ModelState.AddModelError("uploadError", "Supported file extensions: epub");
return(View(viewModel));
}
// extract only the filename
var fileName = Path.GetFileName(Request.Files[0].FileName);
// store the file inside ~/App_Data/uploads folder
var path = Path.Combine(Server.MapPath("~/App_Data/uploads"), fileName);
try
{
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
Request.Files[0].SaveAs(path);
}
catch (Exception)
{
ModelState.AddModelError("uploadError", "Can't save file to disk");
}
if (ModelState.IsValid)
{
using (var data = new DataConnection())
{
var fileUpload = data.CreateNew <FileUpload>();
fileUpload.FileName = fileName;
data.Add(fileUpload);
}
}
return(View(viewModel));
}
public static IEnumerable<XElement> Send(string fromName, string fromEmail, string toEmail, string messageSubject, string message, string company, string website, string address, string phonenumber, string captcha, string captchaEncryptedValue, bool useCaptcha, Guid emailTemplateId)
{
var catpchaIsValid = useCaptcha ? Captcha.IsValid(captcha, captchaEncryptedValue) : true;
#region SubmittedData
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "fromName"),
new XAttribute("Value", fromName));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "fromEmail"),
new XAttribute("Value", fromEmail));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "toEmail"),
new XAttribute("Value", toEmail));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "messageSubject"),
new XAttribute("Value", messageSubject));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "message"),
new XAttribute("Value", message));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "company"),
new XAttribute("Value", company));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "website"),
new XAttribute("Value", website));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "address"),
new XAttribute("Value", address));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "phonenumber"),
new XAttribute("Value", phonenumber));
#endregion
#region Check Errors
if (!catpchaIsValid || string.IsNullOrEmpty(fromName) || string.IsNullOrEmpty(message) || !Regex.IsMatch(fromEmail, EmailPattern, RegexOptions.IgnoreCase))
{
var errorText = new Hashtable();
if (string.IsNullOrEmpty(fromName))
{
errorText.Add("fromName", GetLocalized("ContactForm", "emptyFromNameError"));
}
if (string.IsNullOrEmpty(message))
{
errorText.Add("message", GetLocalized("ContactForm", "emptyMessageError"));
}
if (!Regex.IsMatch(fromEmail, EmailPattern, RegexOptions.IgnoreCase))
{
errorText.Add("fromEmail", GetLocalized("ContactForm", "incorrectEmailError"));
}
if (!catpchaIsValid)
{
errorText.Add("captcha", GetLocalized("ContactForm", "incorrectCaptchaError"));
}
foreach (string key in errorText.Keys)
{
yield return new XElement("Error",
new XAttribute("Fieldname", key),
new XAttribute("ErrorDescription", errorText[key].ToString()));
}
}
#endregion
#region Save data and send Email
else
{
using (DataConnection con = new DataConnection())
{
var newContactFormData = con.CreateNew<ContactFormData>();
newContactFormData.Id = Guid.NewGuid();
newContactFormData.PageId = SitemapNavigator.CurrentPageId;
newContactFormData.Name = fromName;
newContactFormData.Email = fromEmail;
newContactFormData.Subject = messageSubject;
newContactFormData.Message = message;
newContactFormData.IP = HttpContext.Current.Request.UserHostName;
newContactFormData.Date = DateTime.Now;
newContactFormData.Company = company;
newContactFormData.Website = website;
newContactFormData.Address = address;
newContactFormData.PhoneNumber = phonenumber;
con.Add<ContactFormData>(newContactFormData);
#region Send Email
// Get Email template and fill it with item fields values.
var emailTemplate = con.Get<EmailTemplate>().Where(e => e.Id == emailTemplateId).SingleOrDefault();
if (emailTemplate != null)
{
try
{
XDocument document = ResolveFields(newContactFormData, emailTemplate);
var subject = string.Format("{0}: {1}", emailTemplate.Subject, (messageSubject != string.Empty ? messageSubject : fromName));
SendEmail(fromName, fromEmail, "", toEmail, subject, document.ToString());
}
catch (Exception ex)
{
Composite.Core.Log.LogError("Composite.Forms.ContactForm", ex);
}
}
else
{
Composite.Core.Log.LogInformation("Composite.Forms.ContactForm", "Email was not sent because of EmailTemplate was not found.");
}
#endregion
}
}
#endregion
}
private static void MoveDataFromIUserToIUserFormLogin()
{
using (var conn = new DataConnection())
{
var users = conn.Get<IUser>().ToList();
var existingUserLogins = new HashSet<Guid>(conn.Get<IUserFormLogin>().Select(l => l.UserId));
foreach (var user in users.Where(u => !existingUserLogins.Contains(u.Id)))
{
if (string.IsNullOrEmpty(user.PasswordHashSalt) && !string.IsNullOrEmpty(user.EncryptedPassword))
{
throw new InvalidOperationException("User password stored in old format");
}
var userFormLogin = DataConnection.New<IUserFormLogin>();
userFormLogin.UserId = user.Id;
userFormLogin.Folder = user.Group;
userFormLogin.IsLocked = user.IsLocked;
userFormLogin.LockoutReason = user.LockoutReason;
userFormLogin.PasswordHash = user.EncryptedPassword;
userFormLogin.PasswordHashSalt = user.PasswordHashSalt;
conn.Add(userFormLogin);
// Clear out old data
user.IsLocked = false;
user.LockoutReason = 0;
user.Group = null;
user.EncryptedPassword = null;
user.PasswordHashSalt = null;
conn.Update(user);
}
}
}
private void saveCodeActivity_Save_ExecuteCode(object sender, EventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("UserGroup");
List <string> newUserGroupEntityTokens = ActivePerspectiveFormsHelper.GetSelectedSerializedEntityTokens(this.Bindings).ToList();
// If current user belongs to currently edited group -> checking that user won't lost access "Users" perspective
if (!ValidateUserPreservesAdminRights(userGroup, newUserGroupEntityTokens))
{
return;
}
UpdateTreeRefresher updateTreeRefresher = CreateUpdateTreeRefresher(this.EntityToken);
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().Select(f => f.ElementHandle.EntityToken).Single();
IEnumerable <PermissionType> newPermissionTypes = GlobalPermissionsFormsHelper.GetSelectedPermissionTypes(this.Bindings);
UserGroupPermissionDefinition userGroupPermissionDefinition =
new ConstructorBasedUserGroupPermissionDefinition(
userGroup.Id,
newPermissionTypes,
EntityTokenSerializer.Serialize(rootEntityToken)
);
PermissionTypeFacade.SetUserGroupPermissionDefinition(userGroupPermissionDefinition);
UserGroupPerspectiveFacade.SetSerializedEntityTokens(userGroup.Id, newUserGroupEntityTokens);
List <CultureInfo> selectedUserGroupActiveLocales = ActiveLocalesFormsHelper.GetSelectedLocalesTypes(this.Bindings).ToList();
using (var connection = new DataConnection())
{
var existingLocales = connection.Get <IUserGroupActiveLocale>().Where(f => f.UserGroupId == userGroup.Id).ToList();
var toDelete = existingLocales.Where(f => !selectedUserGroupActiveLocales.Contains(new CultureInfo(f.CultureName)));
connection.Delete <IUserGroupActiveLocale>(toDelete);
foreach (var localeToAdd in selectedUserGroupActiveLocales.Where(f => !existingLocales.Any(g => g.CultureName == f.Name)))
{
var toAdd = connection.CreateNew <IUserGroupActiveLocale>();
toAdd.Id = Guid.NewGuid();
toAdd.UserGroupId = userGroup.Id;
toAdd.CultureName = localeToAdd.Name;
connection.Add(toAdd);
}
}
SetSaveStatus(true);
LoggingService.LogEntry("UserManagement",
$"C1 Console user group '{userGroup.Name}' updated by '{UserValidationFacade.GetUsername()}'.",
LoggingService.Category.Audit,
TraceEventType.Information);
if (userGroup.Name != this.GetBinding <string>("OldName"))
{
DataFacade.Update(userGroup);
this.UpdateBinding("OldName", userGroup.Name);
updateTreeRefresher.PostRefreshMesseges(userGroup.GetDataEntityToken());
}
}
public static IEnumerable<XElement> SaveComment(string name, string email, string commentTitle, string commentText, string Captcha)
{
var currentPageId = SitemapNavigator.CurrentPageId;
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "Name"),
new XAttribute("Value", name));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "Email"),
new XAttribute("Value", email));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "CommentTitle"),
new XAttribute("Value", commentTitle));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "CommentText"),
new XAttribute("Value", commentText));
yield return new XElement("SubmittedData",
new XAttribute("Fieldname", "Captcha"),
new XAttribute("Value", Captcha));
// Input error ?
if (Captcha != "true" || string.IsNullOrEmpty(name) || !Validate(RegExpLib.Email, email, true) || string.IsNullOrEmpty(commentTitle) || string.IsNullOrEmpty(commentText))
{
var errorText = new Hashtable();
if (Captcha != "true")
{
errorText.Add("Captcha", "Incorrect Captcha value");
}
if (string.IsNullOrEmpty(name))
{
errorText.Add("Name", "Incorrect Name value");
}
if (!Validate(RegExpLib.Email, email, true))
{
errorText.Add("Email", "Incorrect E-mail value");
}
if (string.IsNullOrEmpty(commentTitle))
{
errorText.Add("Title", "Incorrect Title value");
}
if (string.IsNullOrEmpty(commentText))
{
errorText.Add("Comment", "Incorrect Comment value");
}
foreach (string key in errorText.Keys)
{
yield return new XElement("Error",
new XAttribute("Fieldname", key),
new XAttribute("ErrorDescription", errorText[key].ToString()));
}
}
else
{
using (DataConnection conn = new DataConnection())
{
var currentPage = conn.Get<IPage>().Where(p => p.Id == currentPageId).SingleOrDefault();
if (!currentPage.GetDefinedFolderTypes().Contains(typeof(Item)))
{
currentPage.AddFolderDefinition(typeof(Item).GetImmutableTypeId());
}
//add data
var commentItem = conn.CreateNew<Item>();
commentItem.Name = name;
commentItem.Email = email;
commentItem.Title = commentTitle;
commentItem.Date = DateTime.Now;
commentItem.Comment = commentText;
PageFolderFacade.AssignFolderDataSpecificValues(commentItem, currentPage);
conn.Add<Item>(commentItem);
// Redirect to view newly added comment
string pageUrl;
var found = PageStructureInfo.TryGetPageUrl(currentPageId, out pageUrl);
if (found)
{
PrepareMail(currentPageId, pageUrl, name, email, commentTitle, commentText, DateTime.Now.ToString());
HttpContext.Current.Response.Redirect(pageUrl, false);
}
}
}
}
public static IEnumerable <XElement> SaveComment(string name, string email, string commentTitle, string commentText, string Captcha)
{
var currentPageId = SitemapNavigator.CurrentPageId;
yield return(new XElement("SubmittedData",
new XAttribute("Fieldname", "Name"),
new XAttribute("Value", name)));
yield return(new XElement("SubmittedData",
new XAttribute("Fieldname", "Email"),
new XAttribute("Value", email)));
yield return(new XElement("SubmittedData",
new XAttribute("Fieldname", "CommentTitle"),
new XAttribute("Value", commentTitle)));
yield return(new XElement("SubmittedData",
new XAttribute("Fieldname", "CommentText"),
new XAttribute("Value", commentText)));
yield return(new XElement("SubmittedData",
new XAttribute("Fieldname", "Captcha"),
new XAttribute("Value", Captcha)));
// Input error ?
if (Captcha != "true" || string.IsNullOrEmpty(name) || !Validate(RegExpLib.Email, email, true) || string.IsNullOrEmpty(commentTitle) || string.IsNullOrEmpty(commentText))
{
var errorText = new Hashtable();
if (Captcha != "true")
{
errorText.Add("Captcha", "Incorrect Captcha value");
}
if (string.IsNullOrEmpty(name))
{
errorText.Add("Name", "Incorrect Name value");
}
if (!Validate(RegExpLib.Email, email, true))
{
errorText.Add("Email", "Incorrect E-mail value");
}
if (string.IsNullOrEmpty(commentTitle))
{
errorText.Add("Title", "Incorrect Title value");
}
if (string.IsNullOrEmpty(commentText))
{
errorText.Add("Comment", "Incorrect Comment value");
}
foreach (string key in errorText.Keys)
{
yield return(new XElement("Error",
new XAttribute("Fieldname", key),
new XAttribute("ErrorDescription", errorText[key].ToString())));
}
}
else
{
using (DataConnection conn = new DataConnection())
{
var currentPage = conn.Get <IPage>().Where(p => p.Id == currentPageId).SingleOrDefault();
if (!currentPage.GetDefinedFolderTypes().Contains(typeof(Item)))
{
currentPage.AddFolderDefinition(typeof(Item).GetImmutableTypeId());
}
//add data
var commentItem = conn.CreateNew <Item>();
commentItem.Name = name;
commentItem.Email = email;
commentItem.Title = commentTitle;
commentItem.Date = DateTime.Now;
commentItem.Comment = commentText;
PageFolderFacade.AssignFolderDataSpecificValues(commentItem, currentPage);
conn.Add <Item>(commentItem);
// Redirect to view newly added comment
string pageUrl;
var found = PageStructureInfo.TryGetPageUrl(currentPageId, out pageUrl);
if (found)
{
PrepareMail(currentPageId, pageUrl, name, email, commentTitle, commentText, DateTime.Now.ToString());
HttpContext.Current.Response.Redirect(pageUrl, false);
}
}
}
}
