static void UpdateMetaModel(string commandsFilePath)
{
LogFile.WriteLine("Updating metamodel...");
SchemaDocument schema = new SchemaDocument();
schema.Load(Path.Combine(Settings.InstallDir, @"Code\_Source\Tools\metamodelSchema.xml"));
SyncCommand[] commands = McXmlSerializer.GetObjectFromFile <SyncCommand[]>(commandsFilePath);
using (DataContext dataContext = new DataContext(string.Empty))
{
DataContext.Current = dataContext;
dataContext.SqlContext.CommandTimeout = CommandTimeout;
SqlTransaction previousTransaction = DataContext.Current.SqlContext.Transaction;
using (DBTransaction tran = DBHelper2.DBHelper.BeginTransaction())
{
DataContext.Current.SqlContext.Transaction = tran.SqlTran;
try
{
MetaModelSync.Execute(schema, commands);
tran.Commit();
LogWriteOk();
}
finally
{
DataContext.Current.SqlContext.Transaction = previousTransaction;
}
}
}
}
public virtual async Task <ActionResult <bool> > RemoveLog([FromRoute] long logId)
{
var user = CurrentUser;
if (!table.Access.GetFlag(AccessType.Admin, user))
{
return(Forbid());
}
var logItem = (DBLogItem)table.LogTable.LoadItemById(logId);
if (logItem == null)
{
return(false);
}
using (var transaction = new DBTransaction(table.Connection, user))
{
try
{
await logItem.Delete(transaction);
transaction.Commit();
return(true);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
protected void btn_ImportaListino_Click(object sender, EventArgs e)
{
DBTransaction tr = new DBTransaction();
tr.Begin();
try
{
//// Elimino il listino
//Mamg0DAO.EliminaListino(tr);
//// Reinserisco tutto il listino Mamg0, recuperando i dati da un file excel nominato Mamg0.xlsx
//Mamg0DAO.GetDataFromExcelAndInsertBulkCopy(filePath, tr);
// Nuovo metodo, con txt
// Elimino il listino
List <Mamg0> items = ReadDataFromTextFile();
Mamg0DAO.DeleteListino(tr);
Mamg0DAO.InsertListino(items, tr);
tr.Commit();
lblImportMsg.Text = "Importazione del listino avvenuta con successo";
lblImportMsg.ForeColor = Color.Blue;
}
catch (Exception ex)
{
tr.Rollback();
lblImportMsg.Text = "Errore durante l'importazione del listino. <br />" + ex;
lblImportMsg.ForeColor = Color.Red;
}
// Aggiorno la tabella di visualizzazione risultati
BindGrid();
}
public virtual async Task <ActionResult <bool> > Delete([FromRoute] K id)
{
var value = default(T);
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
value = table.LoadById(id, DBLoadParam.Load | DBLoadParam.Referencing, null, transaction);
if (value == null)
{
return(NotFound());
}
if (!value.Access.GetFlag(AccessType.Delete, transaction.Caller))
{
value.Reject(transaction.Caller);
return(Forbid());
}
await value.Delete(transaction, MaxDeleteDepth, DBLoadParam.Load);
transaction.Commit();
return(Ok(true));
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, value));
}
}
}
public async Task <ActionResult <T> > UndoLog([FromRoute] long logId)
{
var user = CurrentUser;
var logItem = (DBLogItem)table.LogTable.LoadItemById(logId);
if (logItem == null)
{
return(BadRequest($"Not Found!"));
}
if (!table.Access.GetFlag(AccessType.Update, user))
{
return(Forbid());
}
using (var transaction = new DBTransaction(table.Connection, user))
{
try
{
var data = (T)await logItem.Undo(transaction);
transaction.Commit();
return(data);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public async Task <ActionResult <T> > Put([FromBody] T value)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
if (value == null)
{
throw new InvalidOperationException("Some deserialization problem!");
}
if (IsDenied(value, transaction.Caller))
{
value.Reject(transaction.Caller);
return(Forbid());
}
await value.Save(transaction);
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, value));
}
}
return(Ok(value));
}
public async Task <ActionResult <T> > Merge([FromRoute] K id, [FromBody] List <string> ids)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var idValue = table.LoadById <T>(id, DBLoadParam.Load | DBLoadParam.Referencing);
if (idValue == null)
{
return(NotFound());
}
var items = table.LoadItemsById(ids, transaction);
foreach (var item in items)
{
if (!item.Access.GetFlag(AccessType.Delete, transaction.Caller))
{
return(Forbid());
}
}
await idValue.Merge(items, transaction);
transaction.Commit();
return(idValue);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, null));
}
}
}
public async Task <ActionResult <T> > Post([FromBody] T value)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
if (value == null)
{
throw new InvalidOperationException("Some deserialization problem!");
}
if ((value.UpdateState & DBUpdateState.Insert) != DBUpdateState.Insert)
{
value.Reject(transaction.Caller);
return(BadRequest($"Specified Id {value.PrimaryId} is used by another record!"));
}
if (IsDenied(value, transaction.Caller))
{
value.Reject(transaction.Caller);
return(Forbid());
}
await value.Save(transaction);
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, value));
}
}
return(Ok(value));
}
public async Task <ActionResult <IEnumerable <T> > > PostPackage([FromBody] List <T> values)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
T current = null;
try
{
if (values == null)
{
throw new InvalidOperationException("Some deserialization problem!");
}
foreach (var value in values)
{
transaction.AddItem(value, true);
}
foreach (var value in values)
{
current = value;
if (IsDenied(value, transaction.Caller))
{
transaction.Rollback();
return(Forbid());
}
await value.Save(transaction);
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, current));
}
}
return(Ok(values));
}
public async Task <ActionResult <T> > Post([FromBody] T value)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
if (value == null)
{
throw new InvalidOperationException("Some deserialization problem!");
}
if (((value.UpdateState & DBUpdateState.Insert) == DBUpdateState.Insert &&
!value.Access.GetFlag(AccessType.Create, transaction.Caller)) ||
((value.UpdateState & DBUpdateState.Update) == DBUpdateState.Update &&
!value.Access.GetFlag(AccessType.Update, transaction.Caller)))
{
value.Reject(transaction.Caller);
return(Forbid());
}
await value.Save(transaction);
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, value));
}
}
return(Ok(value));
}
public virtual async Task <ActionResult <T> > UploadFile([FromRoute] K id)
{
if (table.FileNameKey == null)
{
return(BadRequest("No file columns presented!"));
}
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var item = table.LoadById(id, DBLoadParam.Load | DBLoadParam.Referencing, null, transaction);
if (item == null)
{
return(NotFound());
}
if (IsDenied(item, transaction.Caller))
{
return(Forbid());
}
var upload = await Upload();
if (upload != null)
{
if (string.IsNullOrEmpty(item.GetValue <string>(table.FileNameKey)))
{
item.SetValue(upload.FileName, table.FileNameKey);
}
if (table.FileLastWriteKey != null)
{
item.SetValueNullable <DateTime>(upload.ModificationDate ?? DateTime.UtcNow, table.FileLastWriteKey);
}
if (table.FileLOBKey != null)
{
await item.SetLOB(upload.Stream, table.FileLOBKey, transaction);
}
else if (table.FileKey != null)
{
await item.SetStream(upload.Stream, table.FileKey, transaction);
}
transaction.Commit();
}
return(item);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public async Task <ActionResult <bool> > Set([FromRoute] string name, [FromBody] AccessUpdatePackage accessPack)
{
if (accessPack == null)
{
return(BadRequest("Missing body parameter: AccessUpdatePack"));
}
var table = GetTable(name);
if (table == null)
{
return(NotFound());
}
if (table is IDBLogTable)
{
return(Forbid("History is Readonly!"));
}
var accessColumn = table.AccessKey;
if (accessColumn == null)
{
return(BadRequest($"Table {table} is not Accessable!"));
}
var temp = new AccessValue(accessPack.Items);
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
foreach (var id in accessPack.Ids)
{
var value = table.LoadItemById(id, DBLoadParam.Load, null, transaction);
if (value == null)
{
transaction.Rollback();
return(NotFound());
}
if (!accessColumn.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!value.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!table.Access.GetFlag(AccessType.Admin, CurrentUser))
{
transaction.Rollback();
return(Forbid());
}
value.Access = temp;
await value.Save(transaction);
}
transaction.Commit();
return(true);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public void Commit()
{
if (!_commitCalled)
{
_commitCalled = true;
if (_transaction != null)
{
_transaction.Commit();
}
}
}
public async Task <ActionResult <IEnumerable <AccessItem> > > Clear([FromRoute] string name, [FromBody] List <string> ids)
{
var table = GetTable(name);
if (table == null)
{
return(NotFound());
}
if (table is IDBLogTable)
{
return(Forbid("History is Readonly!"));
}
var accessColumn = table.AccessKey;
if (accessColumn == null)
{
return(BadRequest($"Table {table} is not Accessable!"));
}
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var firstItem = (DBItem)null;
foreach (var id in ids)
{
var value = table.LoadItemById(id, DBLoadParam.Load, null, transaction);
if (value == null)
{
return(NotFound());
}
if (firstItem == null)
{
firstItem = value;
}
if (!accessColumn.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!value.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!table.Access.GetFlag(AccessType.Admin, CurrentUser))
{
return(Forbid());
}
value.Access = null;
await value.Save(transaction);
}
transaction.Commit();
return(new ActionResult <IEnumerable <AccessItem> >(firstItem.Access.Items));
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public async Task <ActionResult> UploadFile([FromRoute] K id, [FromRoute] string fileName)
{
if (table.FileNameKey == null)
{
return(BadRequest("No file columns presented!"));
}
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var item = table.LoadById(id, DBLoadParam.Load | DBLoadParam.Referencing, null, transaction);
if (item == null)
{
return(NotFound());
}
if (!(item.Access?.GetFlag(AccessType.Update, transaction.Caller) ?? true) &&
!(item.Access?.GetFlag(AccessType.Create, transaction.Caller) ?? true))
{
return(Forbid());
}
foreach (var upload in Upload())
{
if (string.IsNullOrEmpty(fileName) && !string.IsNullOrEmpty(upload.FileName))
{
fileName = upload.FileName;
}
item.SetValue(fileName, table.FileNameKey);
if (table.FileLOBKey != null)
{
await item.SetLOB(upload.Stream, table.FileLOBKey, transaction);
}
else if (table.FileKey != null)
{
await item.SetStream(upload.Stream, table.FileKey, transaction);
}
transaction.Commit();
}
return(Ok());
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public void Dispose()
{
if (DBTransaction != null)
{
DBTransaction.Commit();
DBTransaction.Dispose();
DBTransaction = null;
}
if (DBConnection != null)
{
DBConnection.Dispose();
DBConnection = null;
}
}
public void Convert(DBHelper source, DBHelper target)
{
using (MD47.DataContext dataContext47 = new MD47.DataContext(string.Empty))
{
// Initialize metadata
MD47.DataContext.Current = dataContext47;
MD47.DataContext.Current.SqlContext.CommandTimeout = _commandTimeout;
SqlTransaction previous45Transaction = MD45.MetaDataContext.Current.Transaction;
SqlTransaction previous47Transaction = MD47.DataContext.Current.SqlContext.Transaction;
//SqlTransaction previousDatabaseTransaction = Mediachase.IBN.Database.DbContext.Current.Transaction;
using (DBTransaction tranSource = source.BeginTransaction())
using (DBTransaction tran = target.BeginTransaction())
{
DBHelper2.Init(source);
MD45.MetaDataContext.Current.Transaction = tranSource.SqlTran;
MD47.DataContext.Current.SqlContext.Transaction = tran.SqlTran;
//Mediachase.IBN.Database.DbContext.Current.Transaction = tran.SqlTran;
try
{
Dictionary <int, OrganizationEntity> organizationsById = new Dictionary <int, OrganizationEntity>();
Dictionary <int, ContactEntity> contactsById = new Dictionary <int, ContactEntity>();
ConvertOrganizations(organizationsById);
string companyLocale = (string)target.RunTextScalar("SELECT [Locale] FROM [LANGUAGES] WHERE [IsDefault]=1");
ConvertContacts(companyLocale, organizationsById, contactsById);
UpdateObjects(target, organizationsById, contactsById);
//Update email boxes
UpdateXmlInDatabase(target, organizationsById, contactsById, new ProcessXmlDelegate(UpdateEmailBoxes), "EMailRouterPop3Box", "EMailRouterPop3BoxId", "Settings");
// Update reports
UpdateXmlInDatabase(target, organizationsById, contactsById, new ProcessXmlDelegate(UpdateReports), "Report", "ReportId", "IBNReportTemplate");
tran.Commit();
}
finally
{
MD45.MetaDataContext.Current.Transaction = previous45Transaction;
MD47.DataContext.Current.SqlContext.Transaction = previous47Transaction;
//Mediachase.IBN.Database.DbContext.Current.Transaction = previousDatabaseTransaction;
}
}
}
}
public void Exec(Action <DBTransaction> a)
{
using (var dbTran = new DBTransaction(ConnString))
{
try
{
a(dbTran);
dbTran.Commit();
}
catch
{
dbTran.Rollback();
throw;
}
}
}
protected void btnEliminaListino_Click(object sender, EventArgs e)
{
DBTransaction tr = new DBTransaction();
tr.Begin();
try
{
Mamg0DAO.DeleteListino(tr);
tr.Commit();
}
catch (Exception ex)
{
tr.Rollback();
throw new Exception("Errore durante l'eliminazione del listino MEF", ex);
}
Response.Redirect("~/Listino.aspx");
}
public static async Task CachePermission()
{
using (var transaction = new DBTransaction(DBTable.Connection))
{
try
{
await CachePermission(transaction);
transaction.Commit();
}
catch (Exception ex)
{
Helper.OnException(ex);
transaction.Rollback();
throw ex;
}
}
}
private async void ToolSendClick(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(MessageText))
{
using (var transaction = new DBTransaction())
{
var message = await Message.Send((User)GuiEnvironment.User, GetStaff(), MessageText);
OnSending?.Invoke(message);
transaction.Commit();
}
MessageText = string.Empty;
}
else
{
MessageDialog.ShowMessage(ParentWindow, "Message not specified!");
}
}
public async Task <ActionResult <bool> > SetAccessItems([FromRoute] string name, [FromRoute] string id, [FromBody] List <AccessItem> accessItems)
{
var table = GetTable(name);
if (table == null)
{
return(NotFound());
}
var accessColumn = table.AccessKey;
if (accessColumn == null)
{
return(BadRequest($"Table {table} is not Accessable!"));
}
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var value = table.LoadItemById(id, DBLoadParam.Load, null, transaction);
if (value == null)
{
return(NotFound());
}
if (!accessColumn.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!value.Access.GetFlag(AccessType.Admin, CurrentUser) &&
!table.Access.GetFlag(AccessType.Admin, CurrentUser))
{
return(Forbid());
}
var buffer = value.Access?.Clone();
buffer.Add(accessItems);
value.Access = buffer;
await value.Save(transaction);
transaction.Commit();
return(true);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex));
}
}
}
public async Task <StateInfo> Execute()
{
using (var transaction = new DBTransaction())
{
try
{
var result = await Execute(transaction);
transaction.Commit();
return(result);
}
catch (Exception ex)
{
transaction.Rollback();
Helper.OnException(ex);
throw ex;
}
}
}
public ActionResult <List <K> > GenerateIds([FromRoute] int count)
{
try
{
var list = new List <K>();
using (var transaction = new DBTransaction(table.Connection))
{
for (int i = 0; i < count; i++)
{
list.Add((K)table.PrimaryKey.ParseValue(table.Sequence.GetNext(transaction)));
}
transaction.Commit();
}
return(list);
}
catch (Exception ex)
{
return(BadRequest(ex, null));
}
}
public static BackgroundWorker ExecuteAsync(DBProcedure procedure, DBItem document, Dictionary <string, object> parameters)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
using (var transaction = new DBTransaction(procedure.Schema.Connection, GuiEnvironment.User))
try
{
var args = new ExecuteArgs(document);
e.Result = Execute(procedure, args);
transaction.Commit();
}
catch (Exception ex)
{
e.Result = ex;
}
};
worker.RunWorkerAsync(parameters);
return(worker);
}
protected async void ToolRollbackClick(object sender, EventArgs e)
{
if (list.SelectedItem == null)
{
return;
}
var redo = list.Selection.GetItems <DBLogItem>();
if (redo[0] != null && redo[0].Table.Access.GetFlag(AccessType.Update, GuiEnvironment.User))
{
using (var transaction = new DBTransaction(GuiEnvironment.User))
{
var item = await redo[0].Redo(transaction);
transaction.Commit();
}
}
else
{
MessageDialog.ShowMessage(ParentWindow, "Access denied!");
}
}
private async void Deleting()
{
try
{
using (var transaction = new DBTransaction(row.Table.Schema.Connection, GuiEnvironment.User))
{
foreach (DBItem r in rowsDelete)
{
r.Delete();
await r.Save(transaction);
}
row.Delete();
await row.Save(transaction);
transaction.Commit();
}
}
catch (Exception ex)
{
message = ex.Message;
}
}
/// <summary>
/// Close transaction and connection. If transaction has not been rolled back, it is committed
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
try
{
if (DBTransaction != null)
{
DBTransaction.Commit();
DBTransaction.Dispose();
DBTransaction = null;
}
if (disposeConnection)
{
db.CloseConnection(DBConnection);
}
DBConnection = null;
}
catch
{
// don't care
}
}
public async Task <ActionResult <T> > Merge([FromRoute] K id, [FromBody] List <string> ids)
{
using (var transaction = new DBTransaction(table.Connection, CurrentUser))
{
try
{
var idValue = table.LoadById <T>(id, DBLoadParam.Load | DBLoadParam.Referencing);
if (idValue == null)
{
return(NotFound());
}
await idValue.Merge(ids, transaction);
transaction.Commit();
return(idValue);
}
catch (Exception ex)
{
transaction.Rollback();
return(BadRequest(ex, null));
}
}
}
public static async Task <Message> Send(User from, IEnumerable <DBItem> to, string data)
{
using (var transaction = new DBTransaction(Message.DBTable.Connection, from))
{
try
{
var message = new Message()
{
DateCreate = DateTime.Now,
User = from,
Data = data
};
await message.Save(transaction);
foreach (var staff in to)
{
if (staff != message.User)//&& user.Status == DBStatus.Actual
{
var address = new MessageAddress
{
Message = message,
Staff = staff
};
await address.Save(transaction);
}
}
transaction.Commit();
return(message);
}
catch (Exception ex)
{
Helper.OnException(ex);
transaction.Rollback();
throw ex;
}
}
}
