// PUT odata/Remarks(5)
public async Task <IHttpActionResult> Put([FromODataUri] Guid key, Remark remark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (key != remark.Id)
{
return(BadRequest());
}
db.Entry(remark).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RemarkExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(remark));
}
private void Vote(Remark remark, string userId, bool positive)
{
if (remark.Votes == null)
{
remark.Votes = new List <Vote>();
}
var vote = remark.Votes.SingleOrDefault(x => x.UserId == userId);
if (vote != null)
{
if (vote.Positive)
{
remark.Rating--;
remark.PositiveVotesCount--;
}
else
{
remark.Rating++;
remark.NegativeVotesCount--;
}
remark.Votes.Remove(vote);
}
if (positive)
{
remark.Rating++;
remark.PositiveVotesCount++;
}
else
{
remark.Rating--;
remark.NegativeVotesCount++;
}
}
public async Task <IHttpActionResult> Patch([FromODataUri] Guid key, Delta <Remark> patch)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Remark remark = await db.Remarks.FindAsync(key);
if (remark == null)
{
return(NotFound());
}
patch.Patch(remark);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RemarkExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(remark));
}
public IActionResult Put([FromODataUri] Guid key, Remark remark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (var trans = context.Database.BeginTransaction())
{
try
{
if (context.Remarks.Find(key) == null)
{
return(NotFound());
}
//context = new ApplicationDbContext(context.Options);
var local = context.Remarks.Local.FirstOrDefault(it => it.RemarkID.Equals(key));
if (local != null)
{
context.Entry(local).State = EntityState.Detached;
}
context.Entry(remark).State = EntityState.Modified;
context.SaveChanges();
trans.Commit();
return(Ok(remark));
}
catch (Exception ex)
{
trans.Rollback();
return(BadRequest(ex));
}
}
}
private async Task UploadImagesWithDifferentSizesAsync(Remark remark, RemarkUser user, File originalPhoto, string metadata = null)
{
var extension = originalPhoto.Name.Split('.').Last();
var uniqueNumber = _uniqueNumberGenerator.Generate();
var groupId = Guid.NewGuid();
var size = "big";
var fileName = metadata == null
? $"remark_{remark.Id:N}_{uniqueNumber}.{extension}"
: $"remark_{remark.Id:N}_{metadata}_{uniqueNumber}.{extension}";
var baseImageUrl = "";
await _fileHandler.UploadAsync(originalPhoto, fileName, (baseUrl, fullUrl) =>
{
baseImageUrl = baseUrl;
remark.AddPhoto(RemarkPhoto.Create(groupId, fileName, size, fullUrl, user, metadata));
});
var smallImageFileName = $"200x200/{fileName}";
var mediumImageFileName = $"600x600/{fileName}";
var smallImageUrl = $"{baseImageUrl}/{smallImageFileName}";
var mediumImageUrl = $"{baseImageUrl}/{mediumImageFileName}";
remark.AddPhoto(RemarkPhoto.Create(groupId, smallImageFileName, "small", smallImageUrl, user, metadata));
remark.AddPhoto(RemarkPhoto.Create(groupId, mediumImageFileName, "medium", mediumImageUrl, user, metadata));
//Trigger resizing images using AWS Lambda, so they shall be accessible with https.
await Task.WhenAll(new List <Task>
{
TriggerImageResizeAsync(smallImageUrl),
TriggerImageResizeAsync(mediumImageUrl)
});
}
protected static void Initialize()
{
InitializeBase();
CommandHandler = new ResolveRemarkHandler(Handler,
BusClientMock.Object,
RemarkServiceMock.Object,
GroupServiceMock.Object,
RemarkStateServiceMock.Object,
FileResolverMock.Object,
FileValidatorMock.Object,
ResourceFactoryMock.Object);
Command.Photo = new Collectively.Messages.Commands.Models.File
{
Base64 = "base64",
Name = "file.png",
ContentType = "image/png"
};
Command.ValidateLocation = true;
Command.ValidatePhoto = true;
Remark.SetResolvedState(User, Description, Location);
File = File.Create(Command.Photo.Name, Command.Photo.ContentType, new byte[] { 0x1 });
FileResolverMock.Setup(x => x.FromBase64(Moq.It.IsAny <string>(),
Moq.It.IsAny <string>(), Moq.It.IsAny <string>())).Returns(File);
FileValidatorMock.Setup(x => x.IsImage(Moq.It.IsAny <File>())).Returns(true);
}
public override bool Equals(object obj)
{
GetRemarkResponse peer = (GetRemarkResponse)obj;
if (peer == null)
{
return(false);
}
if (Object.ReferenceEquals(peer, this))
{
return(true);
}
bool ret = false;
ret = Remark.Equals(peer.Remark);
if (!ret)
{
return(ret);
}
ret = Stat.Equals(peer.Stat);
if (!ret)
{
return(ret);
}
return(ret);
}
public IList <Remark> FindALL(object cid)//找到cid的类中前num的列表
{
List <Remark> list = new List <Remark>();
sql = "select * from Remarks where cid=" + cid + " order by id desc";
ds = DbHelperSQL.GetDataSet(sql);
if (ds == null)
{
return(null);
}
else
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
Remark a = new Remark();
a.Cid = dr["Cid"].ToString();
a.Tel = dr["Tel"].ToString();
a.Email = dr["Email"].ToString();
a.Address = dr["Address"].ToString();
a.About = dr["About"].ToString();
a.BBShelp = dr["BBShelp"].ToString();
a.Ziranhelp = dr["ZiranHelp"].ToString();
a.Shekehelp = dr["ShekeHelp"].ToString();
list.Add(a);
}
return(list);
}
}
// POST odata/Remarks
public async Task <IHttpActionResult> Post(Remark remark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Remarks.Add(remark);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (RemarkExists(remark.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created(remark));
}
public async Task <ActionResult> CreateRemark(string remark, decimal lat, decimal lng)
{
VerifySession();
using (var db = new LandmarkRemarkDbContext())
{
//Find the user based off the stored user session data
var userId = (System.Web.HttpContext.Current.Session["user"] as Models.Transport.User).UserId;
var user = await db.Users.SingleOrDefaultAsync(z => z.UserId == userId);
if (user == null)
{
throw new NullReferenceException("User was not found");
}
//Create a new remark made by the user. I specifically use the 'User' here instead of 'UserId'
//as the mapping method below, FromDb, when the data is returned uses the User.Username
var newRemark = new Remark()
{
User = user,
RemarkText = remark,
Latitude = lat,
Longitude = lng,
DateCreated = DateTime.Now
};
var rems = db.Remarks.Add(newRemark);
await db.SaveChangesAsync();
return(JsonHelper.ToJson(Models.Transport.Remark.FromDb(newRemark)));
}
}
/// <summary>已重载。记录当前管理员</summary>
/// <param name="isNew"></param>
public override void Valid(Boolean isNew)
{
base.Valid(isNew);
if (isNew)
{
// 自动设置当前登录用户
if (!IsDirty(__.UserName))
{
UserName = ManageProvider.Provider?.Current + "";
}
}
// 处理过长的备注
if (!Remark.IsNullOrEmpty() && Remark.Length > 500)
{
Remark = Remark.Substring(0, 500);
}
// 时间
if (isNew && CreateTime.Year < 2000 && !IsDirty(__.CreateTime))
{
CreateTime = DateTime.Now;
}
}
private static Remark ProcessRemarksRow(HtmlElement row)
{
var remark = new Remark();
var i = 0;
foreach (HtmlElement element in row.GetElementsByTagName("td"))
{
if (i == 0)
{
remark.RemarkDate = element.InnerText.ConvertDateToRussianFormat();
}
if (i == 1)
{
remark.LessonName = element.InnerText;
}
if (i == 2)
{
remark.RemarkText = element.InnerText;
}
i++;
}
return(remark);
}
protected override GeneratorDelegate CreateGenerator()
{
return((out IDbParameters pms) =>
{
List <string> list = new List <string>();
pms = Template.CreateDbParameters();
if (!string.IsNullOrWhiteSpace(Id))
{
list.Add("s.\"Id\"=@Id");
pms.AddWithValue("Id", Id);
}
if (!string.IsNullOrWhiteSpace(OperatorId))
{
list.Add("s.\"OperatorId\"=@OperatorId");
pms.AddWithValue("OperatorId", OperatorId);
}
if (StartCreateTime != null)
{
list.Add("s.\"CreateTime\">=@StartCreateTime");
pms.AddWithValue("StartCreateTime", StartCreateTime);
}
if (EndCreateTime != null)
{
list.Add("s.\"CreateTime\"<=@EndCreateTime");
pms.AddWithValue("EndCreateTime", EndCreateTime);
}
if (!string.IsNullOrWhiteSpace(Remark))
{
list.Add("s.\"Remark\" like @Remark");
pms.AddWithValue("Remark", Remark.Wrap("%"));
}
if (!string.IsNullOrWhiteSpace(PrincipalId))
{
list.Add("s.\"PrincipalId\" = @PrincipalId");
pms.AddWithValue("PrincipalId", PrincipalId);
}
if (!string.IsNullOrWhiteSpace(TypeId))
{
list.Add("s.\"TypeId\"=@TypeId");
pms.AddWithValue("TypeId", TypeId);
}
if (!string.IsNullOrWhiteSpace(Name))
{
list.Add("s.\"Name\" like @Name");
pms.AddWithValue("Name", Name.Wrap("%"));
}
if (!string.IsNullOrWhiteSpace(Description))
{
list.Add("s.\"Description\" like @Description");
pms.AddWithValue("Description", Description.Wrap("%"));
}
return list;
});
}
public ProcResult UpdateRemark(Remark remark)
{
ProcResult res = new ProcResult();
Remark obj = new Remark();
try
{
obj = _context.Remarks.Find(remark.OrderId);
obj.EID = remark.EID;
obj.EIDDate = remark.EIDDate;
obj.OrderId = remark.OrderId;
obj.Comment = remark.Comment;
obj.Id = remark.Id;
obj = remark;
obj.UID = remark.UID;
obj.UIDDate = remark.UIDDate;
_context.SaveChanges();
res.ErrorID = 0;
res.strResult = "Remark Updated Sucessfully";
}
catch
{
res.ErrorID = 1;
res.strResult = "Remark Update Failed";
}
return(res);
}
public APIResult SaveRemark(Remark remark)
{
try
{
//List<Remark> remarkList = masterService.GetRemark("", "", "", remark.RemarkName, null);
//if (remarkList != null && remarkList.Count != 0 && remark.RemarkId != remarkList[0].RemarkId)
//{
// return new APIResult() { Status = false, Body = "备注名称重复" };
//}
masterService.SaveRemark(remark);
return(new APIResult()
{
Status = true, Body = ""
});
}
catch (Exception ex)
{
return(new APIResult()
{
Status = false, Body = ex.Message.ToString()
});
}
}
protected static void InitializeBase()
{
InitializeBus();
ExceptionHandlerMock = new Mock <IExceptionHandler>();
Handler = new Handler(ExceptionHandlerMock.Object);
BusClientMock = new Mock <IBusClient>();
RemarkServiceMock = new Mock <IRemarkService>();
GroupServiceMock = new Mock <IGroupService>();
RemarkStateServiceMock = new Mock <IRemarkStateService>();
FileResolverMock = new Mock <IFileResolver>();
FileValidatorMock = new Mock <IFileValidator>();
ResourceFactoryMock = new Mock <IResourceFactory>();
Description = "test";
Command = new TCommand()
{
Request = new Request
{
Name = typeof(TCommand).Name,
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
Origin = "test",
Resource = ""
},
Description = Description,
RemarkId = RemarkId,
UserId = UserId,
Longitude = 1,
Latitude = 1,
};
User = new User(UserId, "user", "user");
Category = new Category("test");
Location = Location.Create(Command.Latitude, Command.Longitude, "address");
Remark = new Remark(RemarkId, User, Category, Location, Description);
RemarkServiceMock.Setup(x => x.GetAsync(Moq.It.IsAny <Guid>())).ReturnsAsync(Remark);
}
public async Task <IHttpActionResult> PutRemark(int id, Remark remark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != remark.RemarkId)
{
return(BadRequest());
}
db.Entry(remark).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RemarkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private void InitDefaultRemark()
{
chkBoxShowAll.Checked = false;
var defRemark =
AryaTools.Instance.InstanceData.Dc.Remarks.FirstOrDefault(r => r.Remark1.ToLower() == DefaultRemark.ToLower());
if (defRemark == null) //Add Default Remark, if it does not exist
{
var rm = new Remark {
IsCanned = true, Remark1 = DefaultRemark, ID = new Guid(DefaultRemarkID)
};
AryaTools.Instance.InstanceData.Dc.Remarks.InsertOnSubmit(rm);
AryaTools.Instance.SaveChangesIfNecessary(true, true);
}
else if (
!AryaTools.Instance.InstanceData.Dc.Remarks.Any(
r => r.Remark1.ToLower() == DefaultRemark.ToLower() && r.IsCanned == true))
{
defRemark.IsCanned = true;
AryaTools.Instance.SaveChangesIfNecessary(true, true);
}
_remarkList = AryaTools.Instance.InstanceData.Dc.Remarks.OrderBy(r => r.Remark1).ToList();
comboBoxRemarks.DataSource = _remarkList.Where(c => c.IsCanned == true).Select(r => r.Remark1).ToList();
var defalutRemark = _remarkList.FirstOrDefault(c => c.IsCanned == true && c.Remark1 == DefaultRemark);
if (defalutRemark != null)
{
comboBoxRemarks.SelectedItem = defalutRemark.Remark1;
chkBoxIsCanned.Checked = defalutRemark.IsCanned ?? false;
}
}
public async Task PublishCommentAddedToRemarkEmailAsync(IEnumerable <UserNotificationSettings> users,
Remark remark, string author, string comment, DateTime date)
{
if (users == null)
{
return;
}
var recipients = users
.Where(u => u.EmailSettings.Enabled && u.EmailSettings.CommentAdded)
.ToList();
foreach (var user in recipients)
{
var message = new SendCommentAddedToRemarkEmailMessage
{
Request = Request.New <SendCommentAddedToRemarkEmailMessage>(),
Address = remark.Location.Address,
Category = await GetTranslatedCategoryAsync(user.Culture, remark.Category.Name),
Email = user.Email,
Date = date,
RemarkId = remark.Id,
Username = author,
Comment = comment,
Culture = user.Culture,
RemarkUrl = $"{_settings.RemarksPath}{remark.Id}"
};
await _busClient.PublishAsync(message);
}
}
private bool IsValidate()
{
if (Progress.Text.Trim() == string.Empty)
{
MessageBox.Show("Progress is Required.", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Progress.Focus();
return(false);
}
if (Conduct.Text.Trim() == string.Empty)
{
MessageBox.Show("Conduct is Required.", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Conduct.Focus();
return(false);
}
if (ReasonForLeaving.Text.Trim() == string.Empty)
{
MessageBox.Show("Reason for Leave is Required.", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
ReasonForLeaving.Focus();
return(false);
}
if (Remark.Text.Trim() == string.Empty)
{
MessageBox.Show("Remark is Required.", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Remark.Focus();
return(false);
}
return(true);
}
public override string ToString(FormatType format, object supplement = null)
{
bool withoutConstant = SongGenreSplash == null;
string splashAndDxData = $"{SongGenreSplash?.Be($"\n分类：{SongGenreSplash}")}" +
$"{ToSplashRatingString()?.Be("\n难度：{0}", true)}" +
$"{ToSplashConstantString()?.Be("\n定数：{0}", true)}" +
$"{ToRatingString()?.Be("\n旧难度：{0}", true)}" +
$"{ToConstantString()?.Be("\n旧定数：{0}", true)}";
switch (format)
{
case FormatType.Brief:
return($"{SongId}.{SongTitle}({SongType}) {(withoutConstant ? $"*[{ToSplashRatingString()}]" : $"[{ToSplashConstantString()}]")}");
case FormatType.Detail:
return($"{JacketUrl?.Be(new KouImage(JacketUrl, this).ToKouResourceString())}" + //BUG 需要解决翻页可能会使得图片资源字符串裂开的问题
$"{SongId}.{SongTitle} [{SongType}]" +
splashAndDxData +
Version?.Be($"\n版本：{Version}") +
SongArtist?.Be($"\n曲师：{SongArtist}") +
SongBpm?.Be($"\nBPM：{SongBpm}") +
SongLength?.Be($"\n歌曲长度：{SongLength}") +
Remark?.Be($"\n注：{Remark}"));
}
return(null);
}
public new void Init()
{
base.Init();
DateTime date;
var arrDate = Size.Split('|');
if (!string.IsNullOrEmpty(arrDate[0]) && DateTime.TryParse(arrDate[0], out date))
{
TravelFromDate = date;
}
else
{
throw new Exception("Can't get the TravelFromDate of OrderItem_TravelPlan.Size");
}
if (!string.IsNullOrEmpty(arrDate[1]) && DateTime.TryParse(arrDate[1], out date))
{
TravelToDate = date;
}
else
{
throw new Exception("Can't get the TravelToDate of OrderItem_TravelPlan.Size");
}
TravelOption = !string.IsNullOrEmpty(Remark) ? Remark.ToUpper().Split('|') : null;
}
public async Task <ActionResult <Remark> > PostRemark(Remark remark)
{
_context.Remark.Add(remark);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRemark", new { id = remark.Id }, remark));
}
public async Task <IActionResult> PutRemark(int id, Remark remark)
{
if (id != remark.Id)
{
return(BadRequest());
}
_context.Entry(remark).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RemarkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
///
/// </summary>
/// <param name="remark"></param>
public void SaveRemark(Remark remark)
{
if (remark.AddCheck == "Y")
{
remark.CheckTypeId = null;
}
Remark findOne = db.Remark.Where(x => (x.RemarkId == remark.RemarkId)).FirstOrDefault();
if (findOne == null)
{
remark.InDateTime = DateTime.Now;
remark.ModifyDateTime = DateTime.Now;
db.Remark.Add(remark);
}
else
{
findOne.ModifyDateTime = DateTime.Now;
findOne.ModifyUserId = remark.ModifyUserId;
findOne.AddCheck = remark.AddCheck;
findOne.RemarkName = remark.RemarkName;
findOne.UseChk = remark.UseChk;
findOne.CheckTypeId = remark.CheckTypeId;
findOne.ProjectId = remark.ProjectId;
}
db.SaveChanges();
}
public override bool Equals(object obj)
{
SetRemarkRequest peer = (SetRemarkRequest)obj;
if (peer == null)
{
return(false);
}
if (Object.ReferenceEquals(peer, this))
{
return(true);
}
bool ret = false;
ret = Path.Equals(peer.Path);
if (!ret)
{
return(ret);
}
ret = Remark.Equals(peer.Remark);
if (!ret)
{
return(ret);
}
ret = (Version == peer.Version);
if (!ret)
{
return(ret);
}
return(ret);
}
protected override void LoadSubClass()
{
string TableNames = "TaxForm";
Fields = TableCache(GUID, ref TableNames, "TaxForm_s");
GUID = Fields["RowGUID"].ToString(); //for the case where TaxForm_s can lookup on OrderNumber as well as GUID
//currently comes back with the following tables loaded: TaxForm, (optional) TaxForm_Weapon or (optional) TaxForm_Vehicle
Fields.PropertyChanged += FieldChange;
SetExtendedFields();
//default state to readonly when form has been filed or voided
_IsReadOnly = iTRAACHelpers.IsBitOn(Fields["StatusFlags"], StatusFlagsForm.Filed) ||
iTRAACHelpers.IsBitOn(Fields["StatusFlags"], StatusFlagsForm.Voided);
//create the logical lookup field for "Location" via TaxForm.LocationCode to TaxOffice.TaxOfficeCode
dsCache.AddRelation("Location", TaxOffice.TaxOfficeTable.Columns["OfficeCode"], TaxFormTable.Columns["LocationCode"], false);
if (!TaxFormTable.Columns.Contains("Location"))
{
TaxFormTable.Columns.Add("Location", typeof(string), "Parent(Location).Office");
}
//create the TaxForm_Remark relationship
dsCache.AddRelation("TaxForm_Remark", TaxFormTable.Columns["RowGUID"], TaxFormRemarksTable.Columns["FKRowGUID"], false);
TaxFormRemarks = Fields.CreateChildView("TaxForm_Remark");
ShowDeletedRemarks = false;
Remark.CommonRemarkTableSettings(TaxFormRemarks);
TaxFormRemarks.Table.RowChanged += TaxFormRemarks_RowChanged;
if (IsIncomplete)
{
Validate(); //flip on all the red boxes so the user is prompted to resolve right away
}
}
public int CompareTo(object obj)
{
SetRemarkRequest peer = (SetRemarkRequest)obj;
if (peer == null)
{
throw new InvalidOperationException("Comparing different types of records.");
}
int ret = 0;
ret = Path.CompareTo(peer.Path);
if (ret != 0)
{
return(ret);
}
ret = Remark.CompareTo(peer.Remark);
if (ret != 0)
{
return(ret);
}
ret = (Version == peer.Version) ? 0 : ((Version < peer.Version) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
return(ret);
}
protected static void Initialize()
{
RemarkRepositoryMock = new Mock <IRemarkRepository>();
UserRepositoryMock = new Mock <IUserRepository>();
RemarkPhotoServiceMock = new Mock <IRemarkPhotoService>();
GeneralSettings = new GeneralSettings
{
AllowedDistance = 15.0
};
RemarkStateService = new RemarkStateService(RemarkRepositoryMock.Object,
UserRepositoryMock.Object,
RemarkPhotoServiceMock.Object,
GeneralSettings);
var user = new User(UserId, "name", "user");
var category = new Category("category");
Description = "test";
Remark = new Remark(RemarkId, user, category, Location);
Remark.AddPhoto(RemarkPhoto.Small(Guid.NewGuid(), "test.jpg", "http://my-test-image.com", RemarkUser.Create(user)));
RemarkRepositoryMock.Setup(x => x.GetByIdAsync(Moq.It.IsAny <Guid>()))
.ReturnsAsync(Remark);
UserRepositoryMock.Setup(x => x.GetByUserIdAsync(Moq.It.IsAny <string>()))
.ReturnsAsync(User);
}
partial void OnRemarkChanged()
{
if (!string.IsNullOrEmpty(_Remark))
{
_Remark = Remark.TextEncode();
}
}
public static void ValidateAndSaveRemark(Remark remarkObject, DataClasses1DataContext dbContext, out List<ResultMessages> messages)
{
ResultMessages result = new ResultMessages();
messages = new List<ResultMessages>();
foreach (RemarkUmkennzeichnung remark in remarkObject.Umkennzeichnung)
{
result = new ResultMessages();
if (getOpenedDeregistrationOrder(remark.Vehicle.VIN).Count == 0 && getOpenedRegistrationOrder(remark.Vehicle.VIN).Count==0)
{
if (ValidateGuid(remark.Header))
{
string valGuid = ValidateGuid(remark.Header, dbContext);
if (valGuid == string.Empty)
{
try
{
CreateRemarkOrder(remark, dbContext);
result.Sucessed = "Sucessed imported VIN: " + remark.Vehicle.VIN;
messages.Add(result);
}
catch (Exception ex)
{
result.Error = ex.Message;
result.Remark = remark;
messages.Add(result);
}
}
else
{
result.Error = valGuid;
result.Remark = remark;
messages.Add(result);
}
}
else
{
result.Error = "Eins oder mehrere Felder im Header sind keine gültigen Guids";
result.Remark = remark;
messages.Add(result);
}
}
else
{
result.Error = "Für dieses Fahrzeug gibt es noch offene Aufträge";
result.Remark = remark;
messages.Add(result);
}
}
}
public List<ResultMessages> VehicleRemark(Remark newRemark, string username, string password, string InternalId)
{
List<ResultMessages> results = new List<ResultMessages>();
List<Guid> allowedCustomers = new List<Guid>();
XMLHelper orderHelper = new XMLHelper();
ResultMessages message = new ResultMessages();
allowedCustomers = CheckLogin.CheckUser(username, password, InternalId);
if (allowedCustomers.Count > 0)
{
using (DataClasses1DataContext dbContext = new DataClasses1DataContext(new Guid(ConfigurationManager.AppSettings["currentUser"])))
{
try
{
dbContext.WriteLogItem("Zugriff von der IP Adresse: " + this.Context.Request.UserHostAddress + "Webservice VehicleRemark()", LogTypes.INFO);
string file = orderHelper.XmlSerializeAndSave(newRemark, OrderTypes.VehicleRemark);
if (File.Exists(file))
{
ValidateOrderType.ValidateAndSaveRemark(newRemark, dbContext, out results);
}
else
{
throw new Exception(file);
}
}
catch (Exception ex)
{
message.Error = "Fehler beim verabeiten der Daten, bitte wiederholen Sie den Vorgang" + Environment.NewLine + "Fehlermeldung: " + ex.Message;
results.Add(message);
}
}
}
return results;
}
