public static ActionResult SqlToJson(string query, string instanceName, bool stored)
{
var res = ActionResult.NoAction;
var customerConfig = CustomerFramework.Load(instanceName);
var dt = new DataTable();
using (SqlConnection con = new SqlConnection(customerConfig.Config.ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.CommandType = stored ? CommandType.StoredProcedure : CommandType.Text;
con.Open();
var adapter = new SqlDataAdapter(cmd);
adapter.Fill(dt);
//convert datatable to list using LINQ. Input datatable is "dt"
var lst = dt.AsEnumerable()
.Select(r => r.Table.Columns.Cast <DataColumn>()
.Select(c => new KeyValuePair <string, object>(c.ColumnName, r[c.Ordinal])
).ToDictionary(z => z.Key, z => z.Value)
).ToList();
//now serialize it
var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var d1 = DateTime.Now;
serializer.MaxJsonLength = 500000000;
res.SetSuccess(serializer.Serialize(lst));
}
}
return(res);
}
/*/// <summary>
* /// Updates item data in database
* /// </summary>
* /// <param name="itemBuilder">Item instance</param>
* /// <param name="fromImport">Indicates if update is from import (not required)</param>
* /// <returns>Result of action</returns>
* public static ActionResult Update(ItemBuilder itemBuilder,long userId, bool fromImport = false)
* {
* return Update(itemBuilder, Basics.ActualInstance.Config.ConnectionString, userId, fromImport);
* }*/
/// <summary>Updates item data in database</summary>
/// <param name="itemBuilder">Item instance</param>
/// <param name="instanceName">Name of instance</param>
/// <param name="userId">User identifier</param>
/// <param name="fromImport">Indicates if update is from import (not required)</param>
/// <returns>Result of action</returns>
public static ActionResult Update(ItemBuilder itemBuilder, string instanceName, long userId, bool fromImport = false)
{
var res = ActionResult.NoAction;
if (itemBuilder == null)
{
res.SetFail("No itemBuilder defined");
return(res);
}
if (string.IsNullOrEmpty(instanceName))
{
res.SetFail("No instance specified");
return(res);
}
string query = SqlServerWrapper.UpdateQuery(itemBuilder, userId);
using (var cmd = new SqlCommand(query))
{
try
{
if (string.IsNullOrEmpty(query))
{
return(ActionResult.NoAction);
}
var instance = CustomerFramework.Load(instanceName);
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
var old = Read.ById(itemBuilder.Id, itemBuilder.Definition, instanceName);
cmd.Connection = cnn;
cmd.Connection.Open();
cmd.ExecuteNonQuery();
res.SetSuccess();
string differences = ItemBuilder.Differences(old, itemBuilder);
if (res.Success)
{
var user = ApplicationUser.GetById(userId, instance.Config.ConnectionString);
ActionLog.Trace(itemBuilder.ItemName + "_", itemBuilder.Id, differences, itemBuilder.ItemName, user.TraceDescription);
res.ReturnValue = "UPDATE";
}
}
}
catch (Exception ex)
{
ExceptionManager.LogException(ex as Exception, "Update:" + query);
res.SetFail(query + "<br />" + ex);
}
finally
{
if (cmd.Connection.State != ConnectionState.Closed)
{
cmd.Connection.Close();
}
}
}
return(res);
}
public static string JsonById(long id, string itemName, string instanceName)
{
var instance = CustomerFramework.Load(instanceName);
var item = new ItemBuilder(itemName, instanceName);
return(SqlStream.GetByQuerySimple(ItemTools.QueryById(item, id), instance.Config.ConnectionString));
}
public static ActionResult Inactive(long itemId, string itemName, string instanceName, long applicationUserId, string userDescription)
{
var instance = new CustomerFramework {
Name = instanceName
};
instance.LoadConfig();
return(ItemBuilder.Inactive(itemId, itemName, applicationUserId, userDescription, instanceName, instance.Config.ConnectionString));
}
public static string GetPhotoGalleryByItemFieldId(string itemName, string itemFieldName, long itemId, string instanceName)
{
var instance = new CustomerFramework {
Name = instanceName
};
instance.LoadConfig();
return(PhotoGallery.JsonList(PhotoGallery.GetByItemFieldId(itemName, itemFieldName, itemId, instance.Config.ConnectionString)));
}
public ActionResult ExportHuman(string itemName, string instanceName)
{
CustomerFramework instance = new CustomerFramework()
{
Name = instanceName
};
instance.LoadConfig();
return(ExportHuman(itemName, instanceName, instance.Config.ConnectionString));
}
/// <summary>Page load event</summary>
/// <param name="sender">This page</param>
/// <param name="e">Event arguments</param>
protected void Page_Load(object sender, EventArgs e)
{
var d0 = DateTime.Now;
string itemName = this.Request.QueryString["ItemName"];
string instanceName = this.Request.QueryString["InstanceName"];
var instance = CustomerFramework.Load(instanceName);
instance.LoadConfig();
var item = new ItemBuilder(itemName, instanceName);
this.Response.Clear();
this.Response.ContentType = "application/json";
if (this.Request.QueryString["r"] == null)
{
this.Response.Write("FK.");
this.Response.Write(itemName);
this.Response.Write(" = ");
}
else
{
this.Response.Write("{\"ItemName\":\"");
this.Response.Write(itemName);
this.Response.Write("\",\"Data\":");
}
if (itemName.Equals("user", StringComparison.OrdinalIgnoreCase))
{
this.Response.Write(ItemBuilder.ListItemJson(ItemBuilder.GetActive(itemName, instance.Name, instance.Config.ConnectionString)));
}
else
{
var parameters = Request.QueryString.Keys.Cast <string>().ToDictionary(k => k, v => Request.QueryString[v]);
parameters = parameters.Where(p => p.Key != "ac" && p.Key != "r" && p.Key != "itemName" && p.Key != "InstanceName").ToDictionary(v => v.Key, v => v.Value);
this.Response.Write(SqlStream.GetFKStream(item, parameters, instance.Config.ConnectionString));
}
if (this.Request.QueryString["r"] == null)
{
this.Response.Write(";");
}
else
{
this.Response.Write(",\"Duration\":");
this.Response.Write(string.Format(CultureInfo.InvariantCulture, "{0:#0.000}", (DateTime.Now - d0).TotalMilliseconds));
this.Response.Write("}");
}
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
/// <summary>Event of page load</summary>
/// <param name="sender">Page loaded</param>
/// <param name="e">Arguments of event</param>
protected void Page_Load(object sender, EventArgs e)
{
CustomerFramework instance = CustomerFramework.Load("AMPA");
string path = instance.DefinitionPath;
var filesPath = Directory.GetFiles(path, "*.item").ToList();
this.files = new List <string>();
foreach (string fileName in filesPath)
{
files.Add(Path.GetFileNameWithoutExtension(fileName));
}
}
private string GetList()
{
var res = new StringBuilder();
var listId = this.Request.QueryString["ListId"];
var itemName = this.Request.QueryString["ItemName"];
var item = new ItemBuilder(itemName, "Playmobil");
var parameters = Request.QueryString.Keys.Cast <string>().ToDictionary(k => k, v => Request.QueryString[v]);
parameters = parameters.Where(p => p.Key != "ApplicationUserId" && p.Key != "_" && p.Key != "Action" && p.Key != "ItemName" && p.Key != "ListId").ToDictionary(v => v.Key, v => v.Value);
var query = ItemTools.QueryByListId(item, parameters, listId);
var instance = CustomerFramework.Load("Playmobil");
return(SqlStream.GetByQuery(query, instance.Config.ConnectionString));
}
/// <summary>Delete an item form database</summary>
/// <param name="itemId">Item identifier</param>
/// <param name="userId">Identifier of user that performs action</param>
/// <param name="userDescription">User description for trace purposses</param>
/// <param name="itemName">Item name</param>
/// <param name="instanceName">Name of actual instance</param>
/// <param name="connectionString">String connection to database</param>
/// <returns>Result of action</returns>
public static ActionResult Delete(long itemId, long userId, string userDescription, string itemName, string instanceName, string connectionString)
{
var res = ActionResult.NoAction;
string query = SqlServerWrapper.DeleteQuery(itemId, userId, itemName, instanceName);
var instance = CustomerFramework.Load(instanceName);
instance.LoadConfig();
using (var cmd = new SqlCommand(query))
{
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
cmd.Connection = cnn;
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
res.SetSuccess(itemName);
ActionLog.Trace(itemName + "_", itemId, "DELETE", instanceName, userDescription);
var item = new ItemBuilder(itemName, instanceName);
/*if (item.Definition.Removes != null)
* {
* if (item.Definition.Removes.Count > 0)
* {
* foreach (string removeItemName in item.Definition.Removes)
* {
* var victims = DataPersistence.GetAllByField(instanceName, removeItemName, itemName + "Id", itemId);
* foreach (ItemBuilder victim in victims)
* {
* Delete(victim.Id, userId, userDescription, removeItemName, instanceName, connectionString);
* }
* }
* }
* }*/
}
catch (Exception ex)
{
res.SetFail(ex);
}
}
}
return(res);
}
/// <summary>Page load event</summary>
/// <param name="sender">This page</param>
/// <param name="e">Event arguments</param>
protected void Page_Load(object sender, EventArgs e)
{
if (this.Request.QueryString["InstanceName"] != null)
{
this.instance = new CustomerFramework {
Name = this.Request.QueryString["InstanceName"]
};
this.instance.LoadConfig();
}
if (this.Request.QueryString["Action"] != null)
{
this.GoAction();
}
if (this.Request.QueryString["GetScript"] != null)
{
this.GoScript();
}
}
public static string SQLJSONStream(string storedName, string instanceName)
{
string res = "[]";
if (!string.IsNullOrEmpty(storedName))
{
var instance = CustomerFramework.Load(instanceName);
using (var cmd = new SqlCommand(storedName))
{
cmd.CommandType = CommandType.StoredProcedure;
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
cmd.Connection = cnn;
res = SQLJSONStream(cmd);
}
}
}
return(res);
}
private string Item_Alumno_GetByCurso()
{
var instance = CustomerFramework.Load("AMPA");
string res = "[]";
var parameters = new List <SqlParameter>
{
DataParameter.Input("@CursoId", Convert.ToInt64(this.Request.QueryString["CursoId"]))
};
try
{
res = SqlStream.GetSqlStream("Item_Alumno_GetByCurso", new ReadOnlyCollection <SqlParameter>(parameters), instance.Config.ConnectionString);
}
catch (Exception ex)
{
ExceptionManager.Trace(ex, "Item_Alumno_GetByCurso(" + Convert.ToInt64(this.Request.QueryString["CursoId"]) + ")");
}
return(res);
}
public static ActionResult DeleteImage(string itemName, long itemId, string fieldName, string instanceName, long applicationUserId)
{
var res = ActionResult.NoAction;
var query = string.Format(
CultureInfo.InvariantCulture,
"UPDATE Item_{0} SET {1} = NULL WHERE Id = {2}",
itemName,
fieldName,
itemId);
var instance = CustomerFramework.Load(instanceName);
using (var cmd = new SqlCommand(query))
{
cmd.CommandType = CommandType.Text;
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
cmd.Connection = cnn;
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
res.SetSuccess();
}
catch (Exception ex)
{
res.SetFail(ex);
}
finally
{
if (cmd.Connection.State != ConnectionState.Closed)
{
cmd.Connection.Close();
}
}
}
}
return(res);
}
public static ActionResult GetAllItems(string instanceName)
{
var res = ActionResult.NoAction;
try
{
var instance = CustomerFramework.Load(instanceName);
string path = instance.DefinitionPath;
var filesPath = Directory.GetFiles(path, "*.item").ToList();
var files = new List <string>();
foreach (string fileName in filesPath)
{
files.Add(Path.GetFileNameWithoutExtension(fileName));
}
res.SetSuccess(files);
}
catch (Exception ex)
{
res.SetFail(ex);
}
return(res);
}
public static ActionResult AddToCollection(long piezaId, long applicationUserId)
{
var res = ActionResult.NoAction;
var customer = CustomerFramework.Load("playmobil");
var actualUser = ApplicationUser.GetById(applicationUserId, customer.Config.ConnectionString);
using (var cmd = new SqlCommand("Item_Pieza_AddToCollection"))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(DataParameter.Input("@PiezaId", piezaId));
cmd.Parameters.Add(DataParameter.Input("@ApplicationUserId", applicationUserId));
using (var cnn = new SqlConnection(customer.Config.ConnectionString))
{
cmd.Connection = cnn;
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
res.SetSuccess();
}
catch (Exception ex)
{
res.SetFail(ex);
}
finally
{
if (cmd.Connection.State != ConnectionState.Closed)
{
cmd.Connection.Close();
}
}
}
}
return(res);
}
public static ActionResult SaveImage(string instanceName, string itemName, string itemField, long itemId, string image)
{
var res = ActionResult.NoAction;
var bytes = Convert.FromBase64String(image);
string path = HttpContext.Current.Request.PhysicalApplicationPath;
if (!path.EndsWith(@"\", StringComparison.OrdinalIgnoreCase))
{
path = path + "\\";
}
path = string.Format(
CultureInfo.InvariantCulture,
@"{0}Instances\\{1}\\Data\img\{2}_{3}_{4}.png",
path,
instanceName,
itemName,
itemField,
itemId);
var url = string.Format(
CultureInfo.InvariantCulture,
@"/Instances/{0}/Data/img/{1}_{2}_{3}.png",
instanceName,
itemName,
itemField,
itemId);
File.WriteAllBytes(path, bytes);
var result = string.Format(
CultureInfo.InvariantCulture,
@"{{""path"":""{0}"",""url"":""{1}?{2}""}}",
path,
url,
Guid.NewGuid().ToString().ToUpperInvariant());
var query = string.Format(
CultureInfo.InvariantCulture,
"UPDATE Item_{0} SET {1} = '{0}_{1}_{2}.png' WHERE Id = {2}",
itemName,
itemField,
itemId);
var instance = CustomerFramework.Load(instanceName);
using (var command = new SqlCommand(query))
{
command.CommandType = CommandType.Text;
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
command.Connection = cnn;
try
{
command.Connection.Open();
command.ExecuteNonQuery();
res.SetSuccess();
}
catch (Exception ex)
{
res.SetFail(ex);
}
finally
{
if (command.Connection.State != ConnectionState.Closed)
{
command.Connection.Close();
}
}
}
}
if (res.Success)
{
res.SetSuccess(result);
}
return(res);
}
/// <summary>Continues PageLoad execution if session is alive</summary>
private void Go()
{
string res = string.Empty;
if (this.Request.QueryString.Count == 0)
{
string instanceName = string.Empty;
if (this.Request.Form["InstanceName"] != null)
{
instanceName = this.Request.Form["InstanceName"];
}
this.instance = CustomerFramework.Load(instanceName);
res = "No Action";
this.errors = new List <Error>();
this.dataFile = new List <DataLine>();
if (!IsPostBack)
{
if (this.Request.Form["itemName"] != null)
{
this.Item = new ItemBuilder(this.Request.Form["itemName"], this.instance.Name);
}
string file = SaveUploadedFile(Request.Files);
if (!string.IsNullOrEmpty(file))
{
file = Path.GetFileName(file);
}
this.dataFile = this.dataFile.OrderBy(d => d.Line).ToList();
this.errors = this.errors.OrderBy(d => d.Linea).ToList();
res = "{\"file\":\"" + file + "\",\"errors\":[";
bool first = true;
foreach (var er in errors)
{
if (first)
{
first = false;
}
else
{
res += ",";
}
res += string.Format(
CultureInfo.InvariantCulture,
@"{{""Type"":""{0}"",""Line"":{1},""Message"":""{2}""}}",
er.ErrorType,
er.Linea,
ToolsJson.JsonCompliant(er.Message));
}
res += "],\"data\":[";
if (this.errors.Count == 0)
{
first = true;
foreach (var dl in this.dataFile)
{
if (first)
{
first = false;
}
else
{
res += ",";
}
res += string.Format(
CultureInfo.InvariantCulture,
@"{{""Type"":""Data"",""Line"":{0},""Message"":{1}}}",
dl.Line,
dl.Data);
}
}
res += string.Format(CultureInfo.InvariantCulture, @"],""ImportId"":""{0}""}}", new Guid());
}
if (this.errors.Count == 0)
{
HttpContext.Current.Session["Import" + this.importId] = this.itemsReaded;
}
this.Response.Clear();
this.Response.Write(res);
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
else
{
var codedQuery = new CodedQuery();
codedQuery.SetQuery(this.Request.QueryString);
string file = codedQuery.GetByKey <string>("file");
string itemName = codedQuery.GetByKey <string>("item");
string importId = codedQuery.GetByKey <string>("importId");
string instanceName = codedQuery.GetByKey <string>("InstanceName");
string resImport = ImportXlsx(file, importId, itemName);
res = "Upload<br />" + file + "<br />" + itemName;
this.Response.Clear();
this.Response.Write(resImport);
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
}
/// <summary>Continues PageLoad execution if session is alive</summary>
private void Go()
{
var d0 = DateTime.Now;
string itemName = this.Request.QueryString["ItemName"];
string instanceName = this.Request.QueryString["InstanceName"];
bool external = false;
var instance = CustomerFramework.Load(instanceName);
var definition = ItemDefinition.Load(itemName, instanceName);
var data = Read.Active(definition, instance.Name);
if (this.Request.QueryString.AllKeys.Count() > 3)
{
var temporalData = data.ToList();
if (this.Request.QueryString.AllKeys.Any(k => k == "InstanceName"))
{
external = true;
foreach (string key in this.Request.QueryString.AllKeys.Where(k => k != "ItemName"))
{
if (!key.Equals("ItemName", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var localKey = key.Remove('_');
object query = this.Request.QueryString[localKey];
if (query.ToString().Contains("EXCLUDE"))
{
long val = Convert.ToInt64(query.ToString().Split('/')[1]);
temporalData = temporalData.Where(d => Convert.ToInt64(d[localKey]) != val).ToList();
}
else if (query.GetType().ToString().ToUpperInvariant() == "SYSTEM.STRING")
{
if (query.ToString().Trim().ToUpperInvariant().Equals("NULL", StringComparison.OrdinalIgnoreCase) || query.ToString().Trim().ToUpperInvariant().Equals("0", StringComparison.OrdinalIgnoreCase))
{
temporalData = temporalData.Where(d => d[localKey] == null || d[localKey].ToString().Trim().Equals("0", StringComparison.OrdinalIgnoreCase)).ToList();
}
else
{
temporalData = temporalData.Where(d => d[localKey] != null && d[localKey].ToString().Equals(query.ToString())).ToList();
}
}
else
{
temporalData = temporalData.Where(d => d[localKey] != null && Convert.ToInt64(d[localKey]) == Convert.ToInt64(query)).ToList();
}
}
data = new ReadOnlyCollection <ItemBuilder>(temporalData);
}
else
{
foreach (string key in this.Request.QueryString.AllKeys.Where(k => k != "ItemName"))
{
var localKey = key;
if (localKey == "callback")
{
external = true;
}
if (localKey == "format" || localKey == "InstanceName" || localKey == "callback" || localKey == "_" || string.IsNullOrEmpty(localKey))
{
continue;
}
if (key.Equals(itemName + "Id"))
{
localKey = "Id";
}
localKey = localKey.Replace("_", string.Empty);
object query = this.Request.QueryString[key];
if (query.ToString().Contains("EXCLUDE"))
{
long val = Convert.ToInt64(query.ToString().Split('/')[1]);
temporalData = temporalData.Where(d => Convert.ToInt64(d[localKey]) != val).ToList();
}
else if (query.GetType().ToString().ToUpperInvariant() == "SYSTEM.STRING")
{
if (query.ToString().Trim().ToUpperInvariant().Equals("NULL", StringComparison.OrdinalIgnoreCase) || query.ToString().Trim().ToUpperInvariant().Equals("0", StringComparison.OrdinalIgnoreCase))
{
temporalData = temporalData.Where(d => d[localKey] == null || d[localKey].ToString().Trim().Equals("0", StringComparison.OrdinalIgnoreCase)).ToList();
}
else
{
temporalData = temporalData.Where(d => d[localKey] != null && d[localKey].ToString().Equals(query.ToString())).ToList();
}
}
else
{
temporalData = temporalData.Where(d => d[localKey] != null && Convert.ToInt64(d[localKey]) == Convert.ToInt64(query)).ToList();
}
}
data = new ReadOnlyCollection <ItemBuilder>(temporalData);
}
}
var d1 = DateTime.Now;
this.Response.Clear();
this.Response.ContentType = "application/json";
var d2 = DateTime.Now;
if (external)
{
string res = string.Format(
CultureInfo.InvariantCulture,
@"{0}",
ItemBuilder.ListItemJson(data).Replace("\n", string.Empty).Replace("\r", string.Empty).Replace("\\", string.Empty).Replace(@"""""""""", @""""""));
this.Response.Write(res);
}
else
{
this.Response.Write(@"{""data"":");
this.Response.Write(ItemBuilder.ListItemJson(data));
this.Response.Write(string.Format(CultureInfo.GetCultureInfo("en-us"), @",""Time"":""{0:#,##0} - {1:#,##0}""}}", (d1 - d0).TotalMilliseconds, (d2 - d1).TotalMilliseconds));
}
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
/*/// <summary>
* /// Inserts item data into database
* /// </summary>
* /// <param name="itemBuilder">Item instance</param>
* /// <param name="fromImport">Indicates if insert is from import (not required)</param>
* /// <returns>Result of action</returns>
* public static ActionResult Insert(ItemBuilder itemBuilder,long userId, bool fromImport = false)
* {
* return Insert(itemBuilder, Basics.ActualInstance.Config.ConnectionString, userId, fromImport);
* }*/
/// <summary>Inserts item data into database</summary>
/// <param name="itemBuilder">Item instance</param>
/// <param name="instanceName">String connection to database</param>
/// <param name="userId">User identifier</param>
/// <param name="fromImport">Indicates if insert is from import (not required)</param>
/// <returns>Result of action</returns>
public static ActionResult Insert(ItemBuilder itemBuilder, string instanceName, long userId, bool fromImport = false)
{
if (itemBuilder == null)
{
return(ActionResult.NoAction);
}
var res = ActionResult.NoAction;
string query = SqlServerWrapper.InsertQuery(itemBuilder, userId);
if (string.IsNullOrEmpty(query))
{
return(ActionResult.NoAction);
}
// Prepare code sequence
/*if (itemBuilder.Definition.Fields.Any(f => !string.IsNullOrEmpty(f.CodeSequence)))
* {
* foreach (ItemField field in itemBuilder.Definition.Fields.Where(f => !string.IsNullOrEmpty(f.CodeSequence)))
* {
* if (itemBuilder[field.Name] != null)
* {
* var codeSequence = CodeSequencePersistence.GetByName(itemBuilder.InstanceName, field.CodeSequence);
* itemBuilder[field.Name] = codeSequence.SetActualValue(userId, connectionString, itemBuilder.InstanceName);
* }
* }
* }*/
using (var cmd = new SqlCommand(query))
{
var instance = CustomerFramework.Load(instanceName);
using (var cnn = new SqlConnection(instance.Config.ConnectionString))
{
cmd.Connection = cnn;
try
{
cmd.Connection.Open();
// ExecuteScalar devuelve el Id del último insertado
var id = cmd.ExecuteScalar();
// PersistentData
if (itemBuilder.ContainsKey("Id"))
{
itemBuilder["Id"] = id;
}
else
{
itemBuilder.Add("Id", id);
}
itemBuilder["Active"] = true;
res.SetSuccess();
res.MessageError = itemBuilder.ItemName;
res.ReturnValue = string.Format(CultureInfo.InvariantCulture, "INSERT|{0}", id);
ActionLog.Trace(itemBuilder.ItemName + "_", itemBuilder.Id, itemBuilder.Json, itemBuilder.InstanceName, instanceName);
}
catch (Exception ex)
{
ExceptionManager.LogException(ex as Exception, "Insert:" + query);
res.SetFail(ex);
}
finally
{
if (cmd.Connection.State != ConnectionState.Closed)
{
cmd.Connection.Close();
}
}
}
}
return(res);
}
protected void Page_Load(object sender, EventArgs e)
{
var res = ActionResult.NoAction;
string path = Request.PhysicalApplicationPath;
try
{
if (this.Request.Files != null && this.Request.Files.Count > 0)
{
long itemId = Convert.ToInt64(this.Request.Form["itemId"]);
string itemName = this.Request.Form["itemName"];
string instanceName = this.Request.Form["InstanceName"];
bool name = this.Request.Form["name"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool normalize = this.Request.Form["normalize"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool serialize = this.Request.Form["serialize"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool replace = this.Request.Form["replace"].Equals("1", StringComparison.OrdinalIgnoreCase);
this.instance = CustomerFramework.Load(instanceName);
var file = this.Request.Files[0];
if (file != null)
{
if (!path.EndsWith("\\"))
{
path += "\\";
}
string fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
itemId,
file.FileName);
if (normalize)
{
string extension = Path.GetExtension(fileName);
if (name)
{
fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}_{2}{3}",
itemName.ToUpperInvariant(),
itemId,
this.Request.Form["fieldName"].ToUpperInvariant(),
extension);
}
else
{
fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}{2}",
itemName.ToUpperInvariant(),
itemId,
extension);
}
}
if (serialize)
{
string serializePath = string.Format(
CultureInfo.InvariantCulture,
@"{0}\Instances\{1}\Data\{2}\",
path,
instance.Name,
itemName);
fileName = Serialize(serializePath, fileName, replace);
}
if (replace)
{
if (normalize)
{
string removePath = string.Format(
CultureInfo.InvariantCulture,
@"{0}\Instances\{1}\Data\{2}\",
path,
instance.Name,
itemName);
Remove(removePath, fileName);
}
}
path = string.Format(
CultureInfo.InvariantCulture,
@"{0}\Instances\{1}\Data\{2}\{3}",
path,
instance.Name,
itemName,
fileName);
file.SaveAs(path);
string fieldNameDB = "Archivo";
if (name)
{
fieldNameDB = this.Request.Form["fieldName"].ToUpperInvariant();
}
var query = new ExecuteQuery()
{
ConnectionString = instance.Config.ConnectionString,
QueryText = string.Format(
CultureInfo.InvariantCulture,
"UPDATE Item_{2} SET {3} = '{0}' WHERE Id = {1}",
fileName,
itemId,
itemName,
fieldNameDB)
};
res = query.ExecuteCommand;
if (res.Success)
{
res.ReturnValue = fileName;
ActionLog.Trace(itemName.ToUpperInvariant() + "_", itemId, fieldNameDB + ":" + fileName, this.instance.Name, this.instance.Config.ConnectionString);
}
}
}
}
catch (Exception ex)
{
res.SetFail(ex);
}
this.Response.Clear();
this.Response.Write(res.Json);
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
protected void Page_Load(object sender, EventArgs e)
{
var res = ActionResult.NoAction;
string path = Request.PhysicalApplicationPath;
try
{
if (this.Request.Files != null && this.Request.Files.Count > 0)
{
long itemId = Convert.ToInt64(this.Request.Form["itemId"]);
string itemName = this.Request.Form["itemName"];
string instanceName = this.Request.Form["InstanceName"];
string userDescription = this.Request.Form["UserDescription"];
bool name = this.Request.Form["name"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool normalize = this.Request.Form["normalize"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool serialize = this.Request.Form["serialize"].Equals("1", StringComparison.OrdinalIgnoreCase);
bool replace = this.Request.Form["replace"].Equals("1", StringComparison.OrdinalIgnoreCase);
var instance = CustomerFramework.Load(instanceName);
var file = this.Request.Files[0];
if (file != null)
{
if (!path.EndsWith("\\"))
{
path += "\\";
}
string fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
itemId,
file.FileName);
if (normalize)
{
string extension = Path.GetExtension(fileName);
if (name)
{
fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}_{2}{3}",
itemName.ToUpperInvariant(),
itemId,
file.FileName.ToUpperInvariant(),
extension);
}
else
{
fileName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}{2}",
itemName.ToUpperInvariant(),
itemId,
extension);
}
}
if (serialize)
{
string serializePath = string.Format(
CultureInfo.InvariantCulture,
@"{0}\CustomersFramework\{1}\Data\{2}\",
path,
instance.Name,
itemName);
fileName = Serialize(serializePath, fileName, replace);
}
path = string.Format(
CultureInfo.InvariantCulture,
@"{0}\CustomersFramework\{1}\Data\DocumentGallery\{2}\{3}",
path,
instance.Name,
itemName,
fileName);
file.SaveAs(path);
if (res.Success)
{
res.ReturnValue = fileName;
ActionLog.Trace(itemName.ToUpperInvariant() + "_", itemId, "DocumentGallery:" + fileName, instance.Config.ConnectionString, userDescription);
}
}
}
}
catch (Exception ex)
{
res.SetFail(ex);
}
this.Response.Clear();
this.Response.Write(res.Json);
this.Response.Flush();
this.Response.SuppressContent = true;
this.ApplicationInstance.CompleteRequest();
}
