public async Task <IActionResult> Move(Guid from, Guid to)
{
Record r = await db.Records.Where(m => m.RecordId == from).FirstOrDefaultAsync();
if (r == null)
{
return(Content("Error"));
}
ReferenceGeometry rg = await db.Geometries.Where(m => m.GeometryId == to).FirstOrDefaultAsync();
if (rg == null)
{
return(Content("Error"));
}
r.GeometryId = rg.GeometryId;
db.Entry(r).State = EntityState.Modified;
User user = Helpers.UserHelper.GetCurrentUser(User, db);
ChangeLog cl = new ChangeLog()
{
Log = "Moved Record to new Geometry", User = user
};
ChangeLogRecord cr = new ChangeLogRecord()
{
ChangeLog = cl, Record = r
};
db.ChangeLogs.Add(cl);
db.ChangeLogsRecords.Add(cr);
await db.SaveChangesAsync();
return(Content("OK"));
}
/// <summary>
/// Consturct a SyncNodeStamp from a ChangeLogRecord.
/// </summary>
/// <param name="record">The record to use.</param>
internal SyncNodeInfo(ChangeLogRecord record)
{
this.ID = record.EventID;
this.LocalIncarnation = record.SlaveRev;
this.MasterIncarnation = record.MasterRev;
this.NodeType = GetSyncNodeType(record.Type.ToString());
switch (record.Operation)
{
case ChangeLogRecord.ChangeLogOp.Changed:
this.Operation = SyncOperation.Change;
break;
case ChangeLogRecord.ChangeLogOp.Created:
this.Operation = SyncOperation.Create;
break;
case ChangeLogRecord.ChangeLogOp.Deleted:
this.Operation = SyncOperation.Delete;
break;
case ChangeLogRecord.ChangeLogOp.Renamed:
this.Operation = SyncOperation.Rename;
break;
default:
this.Operation = SyncOperation.Unknown;
break;
}
}
public void DeleteChangeLogRecord(ChangeLogRecord changeLogRecord)
{
using var command = new MySqlCommand(ChangeLogDeleteQuery, _connection);
command.Parameters.AddWithValue("?Version", changeLogRecord.Version.ToString());
command.Parameters.AddWithValue("?Number", changeLogRecord.Number);
command.ExecuteNonQuery();
}
public ChangeLogRecord FindLatestChangeLogRecord()
{
using var command = new MySqlCommand(ChangeLogSelectLatestQuery, _connection);
using var reader = command.ExecuteReader();
ChangeLogRecord changeLogRecord = null;
if (reader.HasRows)
{
reader.Read();
changeLogRecord = new ChangeLogRecord(
Version.Parse(reader.GetString("Version")),
reader.GetInt32("Number"),
reader.IsDBNull(reader.GetOrdinal("Error")) ? null : reader.GetString("Error"));
}
return(changeLogRecord);
}
public async Task <IActionResult> Delete(Guid id)
{
User user = Helpers.UserHelper.GetCurrentUser(User, db);
Record r = await db.Records
.Include(m => m.ProjectGroup).ThenInclude(pg => pg.Group).ThenInclude(g => g.GroupUsers)
.Where(m => m.RecordId == id).FirstOrDefaultAsync();
if (r == null)
{
return(StatusCode(404));
}
// No right for it, User is not in Group
if ((r.ProjectGroup.Group.GroupUsers.Any(m => m.UserId == user.UserId)) || User.IsInRole("DM"))
{
r.StatusId = StatusEnum.deleted;
ChangeLog cl = new ChangeLog()
{
Log = "deleted record", User = user
};
db.ChangeLogs.Add(cl);
ChangeLogRecord clr = new ChangeLogRecord()
{
ChangeLog = cl, Record = r
};
db.ChangeLogsRecords.Add(clr);
db.Entry(r).State = EntityState.Modified;
await db.SaveChangesAsync();
return(Content("OK"));
}
// No right for it, User is not in Group
return(StatusCode(403));
}
private void UpdateChangeLog(long elapsedMilliseconds, List <ValueRecord> values)
{
var changeLogs = _changeLogRepo.Get().ToList();
var changeLogRecord = new ChangeLogRecord
{
Version = changeLogs.Any() ? changeLogs.Max(x => x.Version) + 1 : 1,
SortType = _currentSortDirection.GetRecord(),
TimeTaken = elapsedMilliseconds,
Values = new List <ChangeLogValueRecord>()
};
for (var i = 0; i < values.Count; i++)
{
changeLogRecord.Values.Add(new ChangeLogValueRecord
{
Value = values[i],
Position = i + 1
});
}
_changeLogRepo.Add(changeLogRecord);
_unitOfWork.Save();
}
private void Apply(ChangeScript changeScript)
{
Exception exception = null;
using (var transaction = _provider.BeginTransaction())
{
try
{
_provider.ApplyChangeScript(changeScript);
_logger.LogInformation($"Database script #{changeScript.Number} of version {changeScript.Version} has been applied.");
transaction.Commit();
}
catch (Exception ex)
{
exception = ex;
}
}
var changeLogRecord = new ChangeLogRecord(changeScript, exception);
using (var transaction = _provider.BeginTransaction())
{
_provider.DeleteChangeLogRecord(changeLogRecord);
_provider.InsertChangeLogRecord(changeLogRecord);
transaction.Commit();
}
if (!changeLogRecord.IsSuccessful)
{
_provider.Disconnect();
throw changeLogRecord.Exception;
}
}
private IEnumerable <ChangeScript> FindAllChangeScripts(string path, string database, ChangeLogRecord latestChangeLogRecord)
{
return(_changeScripts.FindAll(Path.Combine(path, database),
latestChangeLogRecord.Version,
latestChangeLogRecord.Number));
}
// Copy all values from the last record from the user with the same form
public void CopyRecordFromLastEntry(Record record, Form form, User user)
{
try
{
List <ChangeLogRecord> lastRecordChangeLogs = db.ChangeLogsRecords.AsNoTracking()
.Include(m => m.ChangeLog)
.Include(m => m.Record).ThenInclude(r => r.TextData)
.Include(m => m.Record).ThenInclude(r => r.NumericData)
.Include(m => m.Record).ThenInclude(r => r.BooleanData)
.Include(m => m.Record).ThenInclude(r => r.Form).ThenInclude(m => m.FormFormFields).ThenInclude(m => m.FormField)
.Where(m => m.ChangeLog.UserId == user.UserId && m.Record.FormId == form.FormId && m.ChangeLog.Log.Contains("created") && m.Record.StatusId != StatusEnum.deleted && m.Record != record).ToList();
if (lastRecordChangeLogs == null)
{
return;
}
ChangeLogRecord lastRecordChangeLog = lastRecordChangeLogs.OrderBy(m => m.ChangeLog.ChangeDate).Last();
foreach (FormFormField fff in lastRecordChangeLog.Record.Form.FormFormFields)
{
if ((fff.FormField.FieldTypeId == FieldTypeEnum.Choice) || (fff.FormField.FieldTypeId == FieldTypeEnum.Text) || (fff.FormField.FieldTypeId == FieldTypeEnum.DateTime))
{
TextData td = lastRecordChangeLog.Record.TextData.Where(m => m.FormFieldId == fff.FormFieldId).FirstOrDefault();
if (td != null)
{
TextData tdCopy = new TextData()
{
Id = Guid.NewGuid(), FormFieldId = fff.FormFieldId, Record = record, Value = td.Value
};
//if (record.TextData == null) record.TextData = new List<TextData>();
record.TextData.Add(tdCopy);
db.TextData.Add(tdCopy);
}
}
else if (fff.FormField.FieldTypeId == FieldTypeEnum.Number)
{
NumericData td = lastRecordChangeLog.Record.NumericData.Where(m => m.FormFieldId == fff.FormFieldId).FirstOrDefault();
if (td != null)
{
NumericData tdCopy = new NumericData()
{
Id = Guid.NewGuid(), FormFieldId = fff.FormFieldId, Record = record, Value = td.Value
};
//if (record.NumericData == null) record.NumericData = new List<NumericData>();
record.NumericData.Add(tdCopy);
db.NumericData.Add(tdCopy);
db.Entry(tdCopy).State = EntityState.Added;
}
}
else if (fff.FormField.FieldTypeId == FieldTypeEnum.Boolean)
{
BooleanData td = lastRecordChangeLog.Record.BooleanData.Where(m => m.FormFieldId == fff.FormFieldId).FirstOrDefault();
if (td != null)
{
BooleanData tdCopy = new BooleanData()
{
Id = Guid.NewGuid(), FormFieldId = fff.FormFieldId, Record = record, Value = td.Value
};
//if (record.BooleanData == null) record.BooleanData = new List<BooleanData>();
record.BooleanData.Add(tdCopy);
db.BooleanData.Add(tdCopy);
db.Entry(tdCopy).State = EntityState.Added;
}
}
}
}
catch (Exception e)
{
// No form found... we cannot copy anything
return;
}
//db.SaveChanges();
}
public async Task <IActionResult> Save(IFormCollection form)
{
try
{
JObject parameters = form.ToJObject();
string recordID = parameters.GetValue("RecordId").ToString();
if (recordID != null)
{
Record r = await db.Records.Include(m => m.TextData).ThenInclude(td => td.FormField)
.Include(u => u.NumericData).ThenInclude(td => td.FormField)
.Include(u => u.BooleanData).ThenInclude(td => td.FormField)
.Include(u => u.Form).ThenInclude(m => m.FormFormFields).ThenInclude(fff => fff.FormField)
.Include(u => u.Form).ThenInclude(m => m.FormFormFields).ThenInclude(fff => fff.FormField).ThenInclude(mo => mo.PublicMotherFormField)
.Where(m => m.RecordId == new Guid(recordID)).FirstOrDefaultAsync();
foreach (FormField ff in r.Form.FormFormFields.Select(fff => fff.FormField))
{
if (ff.FieldTypeId == FieldTypeEnum.Text)
{
if (parameters.GetValue("Field_" + ff.FormFieldId) != null)
{
string newValue = parameters.GetValue("Field_" + ff.FormFieldId).ToString();
TextData td = r.TextData.Where(m => m.FormField.FormFieldId == ff.FormFieldId).FirstOrDefault();
if (td == null)
{
td = new TextData()
{
FormField = ff, Record = r, Id = Guid.NewGuid(), Value = newValue
};
r.TextData.Add(td);
db.Entry(td).State = EntityState.Added;
db.Entry(r).State = EntityState.Modified;
}
else
{
td.Value = newValue;
db.Entry(td).State = EntityState.Modified;
}
}
}
else if (ff.FieldTypeId == FieldTypeEnum.DateTime)
{
if (parameters.GetValue("Field_" + ff.FormFieldId) != null)
{
string newValue = parameters.GetValue("Field_" + ff.FormFieldId).ToString();
DateTime myDT;
myDT = DateTime.ParseExact(newValue.Replace("{0:", " ").Replace("}", ""), formats, CultureInfo.InvariantCulture, DateTimeStyles.None);
string zulu = myDT
.ToString("yyyy-MM-ddTHH\\:mm\\:sszzz");
TextData td = r.TextData.Where(m => m.FormField.FormFieldId == ff.FormFieldId).FirstOrDefault();
if (td == null)
{
td = new TextData()
{
FormField = ff, Record = r, Id = Guid.NewGuid(), Value = zulu
};
r.TextData.Add(td);
db.Entry(td).State = EntityState.Added;
db.Entry(r).State = EntityState.Modified;
}
else
{
td.Value = zulu;
db.Entry(td).State = EntityState.Modified;
}
}
}
else if (ff.FieldTypeId == FieldTypeEnum.Choice)
{
if (parameters.GetValue("Field_" + ff.FormFieldId) != null)
{
string newValue = parameters.GetValue("Field_" + ff.FormFieldId).ToString();
await db.Entry(ff).Collection(m => m.FieldChoices).LoadAsync();
FieldChoice fc = ff.FieldChoices.Where(m => m.Text == newValue).FirstOrDefault();
if (ff.PublicMotherFormField != null)
{
await db.Entry(ff.PublicMotherFormField).Collection(m => m.FieldChoices).LoadAsync();
fc = ff.PublicMotherFormField.FieldChoices.Where(m => m.Text == newValue).FirstOrDefault();
}
TextData td = r.TextData.Where(m => m.FormField.FormFieldId == ff.FormFieldId).FirstOrDefault();
if (td == null)
{
td = new TextData()
{
FormField = ff, Record = r, Id = Guid.NewGuid(), Value = newValue, FieldChoice = fc
};
r.TextData.Add(td);
db.Entry(td).State = EntityState.Added;
db.Entry(r).State = EntityState.Modified;
}
else
{
td.Value = newValue;
td.FieldChoice = fc;
db.Entry(td).State = EntityState.Modified;
}
}
}
else if (ff.FieldTypeId == FieldTypeEnum.Boolean)
{
if (parameters.GetValue("Field_" + ff.FormFieldId) != null)
{
bool newValue = (bool)parameters.GetValue("Field_" + ff.FormFieldId).ToObject <bool>();
BooleanData bd = r.BooleanData.Where(m => m.FormField.FormFieldId == ff.FormFieldId).FirstOrDefault();
if (bd == null)
{
bd = new BooleanData()
{
FormField = ff, Record = r, Id = Guid.NewGuid(), Value = newValue
};
r.BooleanData.Add(bd);
db.Entry(bd).State = EntityState.Added;
db.Entry(r).State = EntityState.Modified;
}
else
{
bd.Value = newValue;
db.Entry(bd).State = EntityState.Modified;
}
}
}
}
User user = Helpers.UserHelper.GetCurrentUser(User, db);
ChangeLog cl = new ChangeLog()
{
Log = user.UserId + " changed the record", User = user
};
ChangeLogRecord clr = new ChangeLogRecord()
{
Record = r, ChangeLog = cl
};
if (r.RecordChangeLogs == null)
{
r.RecordChangeLogs = new List <ChangeLogRecord>();
}
r.RecordChangeLogs.Add(clr);
await db.SaveChangesAsync();
}
return(Content("OK"));
}
catch (Exception e)
{
return(Content(e.ToString()));;
}
}
public async Task <IActionResult> AddToProject(Guid ProjectId, Guid GroupId, int FormId, bool CopyFromLast = false)
{
User user = Helpers.UserHelper.GetCurrentUser(User, db);
List <Group> myGroups = await db.Groups.Where(m => m.GroupUsers.Any(u => u.UserId == user.UserId)).ToListAsync();
List <Project> projects = new List <Project>();
if (User.IsInRole("DM"))
{
projects = await DB.Helpers.ProjectManager.UserProjectsAsync(db, user, RoleEnum.DM);
}
if (User.IsInRole("EF"))
{
projects.AddRange(await DB.Helpers.ProjectManager.UserProjectsAsync(db, user, RoleEnum.EF));
}
if (User.IsInRole("PK"))
{
projects.AddRange(await DB.Helpers.ProjectManager.UserProjectsAsync(db, user, RoleEnum.PK));
}
if (User.IsInRole("PL"))
{
projects.AddRange(await DB.Helpers.ProjectManager.UserProjectsAsync(db, user, RoleEnum.PL));
}
Project p = await db.Projects.FindAsync(ProjectId);
Form f = await db.Forms.FindAsync(FormId);
// Check if correct rights for user
if ((myGroups.Any(m => m.GroupId == GroupId)) && (projects.Any(m => m.ProjectId == ProjectId)) && (p != null) && (f != null))
{
Record r = new Record()
{
Form = f, ProjectGroupGroupId = GroupId, ProjectGroupProjectId = ProjectId
};
ChangeLog cl = new ChangeLog()
{
Log = "created new record", User = user
};
db.ChangeLogs.Add(cl);
ChangeLogRecord clr = new ChangeLogRecord()
{
ChangeLog = cl, Record = r
};
db.ChangeLogsRecords.Add(clr);
db.Records.Add(r);
await db.SaveChangesAsync();
if (CopyFromLast)
{
CopyRecordFromLastEntry(r, f, user);
}
await db.SaveChangesAsync();
return(Content("OK"));
}
return(StatusCode(403));
}
