/// <summary>
/// This method will validate a property value in a <see cref="BaseModel"/> object asyncronously.
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> to validate.</param>
/// <param name="value">The value to validate.</param>
/// <param name="propertyName">The name of the property to validate.</param>
/// <param name="callback">A <see cref="AsyncCallback"/> that will be called when the operation completes.</param>
/// <param name="state">A user defined object providing state to the asycronous operation.</param>
/// <returns>A <see cref="IAsyncResult"/> object representing the asyncronous operation.</returns>
/// <exception cref="InvalidOperationException">If the engine is not initialized</exception>
public static IAsyncResult BeginValidateProperty(BaseModel model, object value, string propertyName, AsyncCallback callback, object state)
{
if (!_isInitialized)
throw new InvalidOperationException("You must initialize the engine before it is used.");
return new ValidatePropertyAsyncResult(CurrentValidator, model, value, propertyName, callback, state);
}
/// <summary>
/// This method will validate a <see cref="BaseModel"/> asyncronously. Also, if the children of the given
/// model need to be validated at the same time, it can do that as well.
/// </summary>
/// <param name="target">A <see cref="BaseModel"/> to validate.</param>
/// <param name="validateChildren">If the chilren of the given model should be validated as well, supply true.</param>
/// <param name="callback">A <see cref="AsyncCallback"/> that will be called when the operation completes.</param>
/// <param name="state">A user defined object providing state to the asycronous operation.</param>
/// <returns>A <see cref="IAsyncResult"/> object representing the asyncronous operation.</returns>
/// <exception cref="InvalidOperationException">If the engine is not initialized</exception>
public static IAsyncResult BeginValidateModel(BaseModel target, bool validateChildren, AsyncCallback callback, object state)
{
if (!_isInitialized)
throw new InvalidOperationException("You must initialize the engine before it is used.");
return new ValidateModelAsyncResult(CurrentValidator, target, validateChildren, callback, state);
}
public StaticPageBaseModel(BaseModel baseModel)
: base(baseModel)
{
CurrentLanguage = LanguageType.Default;
StaticPageTransport = new StaticPageTransport();
SubNavigationType = SubNavigationType.None;
}
public static void RegisterModel(BaseModel model)
{
var timer = new DispatcherTimer();
timer.Interval = model.Interval;
timer.Tick += model.TimerTick;
timer.Start();
}
public BaseModel.OperationResult<int> CreateSolution(BaseModel.SolutionConfiguration solution)
{
return FunctionResultProxy.GetResult<OperationResult<int>>(delegate (OperationResult<int> r)
{
r.Data = SolutionConfigurationDal.Create(solution);
r.ActionResult = (r.Data > 0);
return r;
});
}
public BaseModel.OperationResult<int> CreateComponentConfig(BaseModel.ComponentConfiguration componentConfig)
{
return FunctionResultProxy.GetResult<OperationResult<int>>(delegate (OperationResult<int> r)
{
r.Data = ComponentConfigurationDal.Create(componentConfig);
r.ActionResult = (r.Data > 0);
return r;
});
}
public static BaseModel CreateBaseModel(Guid sID)
{
BaseModel model = new BaseModel();
model.Initialize(sID);
model.Action = TabModelHelper.DefaultAction(sID);
model.Controller = TabModelHelper.DefaultController(sID);
return model;
}
/// <summary>
/// Controller which returns the home index page.
/// No data calls or parameters are needed for this
///
/// Accessed via /Home/index
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
BaseModel model = new BaseModel();
List<Breadcrumb> trail = new List<Breadcrumb>();
trail.Add(new Breadcrumb() { LinkText = "Home", Action = "Index", Controller = "Home", isCurrent = true });
model.Breadcrumbs = trail;
return View(model);
}
public BaseModel Create(BaseModel model)
{
Category entity = (Category) model;
if (entity.IsValid)
{
_db.Categories.Add(entity);
_db.SaveChanges();
}
return entity;
}
public BaseModel Create(BaseModel model)
{
Book entity = (Book) model;
if (entity.IsValid)
{
_db.Books.Add(entity);
_db.SaveChanges();
}
return entity;
}
public BaseModel Create(BaseModel model)
{
Author entity = (Author)model;
if (entity.IsValid)
{
_db.Authors.Add(entity);
_db.SaveChanges();
}
return entity;
}
public BaseModel Update(BaseModel model)
{
Book entity = _db.Books.Find(((Book) model).Id);
if (entity == null)
throw new NotImplementedException("Something needs to be done...");
if (entity.IsValid)
{
_db.Entry(model).CurrentValues.SetValues(model);
_db.SaveChanges();
}
return entity;
}
public JsonResult SetProductToSocet(string productId, string socetId, int count)
{
var model = new BaseModel();
if ((productId != string.Empty) && (socetId != string.Empty) && (count > 0))
{
var result = SocetProductsService.AddProductIdToSocetId(productId, socetId, count);
model = Mapper.Map<BaseModel>(result);
}
else
{
model.SetError(ResError.DataEmpty);
}
return Json(model, JsonRequestBehavior.AllowGet);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
BaseModel model = new BaseModel();
model.HtmlTitle = _pageInfos[PageInfoType.HtmlTitle];
model.HtmlMetaDescription = _pageInfos[PageInfoType.HtmlMetaDescription];
model.TagModel = new TagModel { PageName = _pageInfos[PageInfoType.TagModel]};
model.CssContainerId = _pageInfos[PageInfoType.CssContainerId];
model.CssContainerClass = _pageInfos[PageInfoType.CssContainerClass];
filterContext.Controller.ViewBag.OmnitureUrl = WebConfigurationManager.AppSettings["OmnitureSrc"];
filterContext.Controller.ViewData.Model = model;
// Default value for special omniture tags
filterContext.Controller.ViewBag.OmnitureEvent = "";
filterContext.Controller.ViewBag.OmnitureVar25 = "";
base.OnActionExecuting(filterContext);
}
/// <summary>
/// This method will validate a property value in a <see cref="BaseModel"/> object.
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> to validate.</param>
/// <param name="value">The value to validate.</param>
/// <param name="propertyName">The name of the property to validate.</param>
/// <returns>A boolean value indicating whether the validation was successful or not.</returns>
/// <exception cref="InvalidOperationException">If the engine is not initialized</exception>
public static bool ValidateProperty(BaseModel model, object value, string propertyName)
{
if (!_isInitialized)
throw new InvalidOperationException("You must initialize the engine before it is used.");
IEnumerable<object> validationErrors = CurrentValidator.ValidateProperty(model, value, propertyName);
ValidationErrorCollection errorCollection = (model as IValidationInteraction).ValidationErrors;
CurrentManager.SetMemberErrors(errorCollection, validationErrors, propertyName);
return validationErrors.Count() == 0;
}
/// <summary>
/// 整版复制
/// </summary>
/// <param name="plate"></param>
/// <returns></returns>
public PlateModel CopyPlate(PlateModel plate)
{
PlateModel copyPlate = new PlateModel();
BaseModel newOutModel = new BaseModel();
for (int i = 0; i < plate.OutModel.ListShape.Count; i++)
{
newOutModel.ListShape.Add(copy(plate.OutModel.ListShape[i]));
}
for (int i = 0; i < plate.OutModel.ExpandShape.Count; i++)
{
newOutModel.ExpandShape.Add(copy(plate.OutModel.ExpandShape[i]));
}
newOutModel.ListPoint.AddRange(plate.OutModel.ListPoint);
newOutModel.ExpandPoint.AddRange(plate.OutModel.ExpandPoint);
newOutModel.IsArc = plate.OutModel.IsArc;
newOutModel.IsInner = plate.OutModel.IsInner;
newOutModel.Area = plate.OutModel.Area;
newOutModel.Bound = plate.OutModel.Bound;
newOutModel.ModelId = CADInterface.globalModelID;
CADInterface.globalModelID = CADInterface.globalModelID + 1;
//CADInterface .currentPlates .Add(newOutModel);
//newOutModel.Draw(CADInterface.bGrp.Graphics);
copyPlate.OutModel = newOutModel;
if (plate.InnerModel.Count > 0)
{
for (int i = 0; i < plate.InnerModel.Count; i++)
{
BaseModel newInnerModel = new BaseModel();
for (int j = 0; j < plate.InnerModel[i].ListShape.Count; j++)
{
newInnerModel.ListShape.Add(copy(plate.InnerModel[i].ListShape[i]));
}
newInnerModel.ListPoint.AddRange(plate.InnerModel[i].ListPoint);
newInnerModel.IsArc = plate.InnerModel[i].IsArc;
newInnerModel.IsInner = plate.InnerModel[i].IsInner;
newInnerModel.Area = plate.InnerModel[i].Area;
newInnerModel.Bound = plate.InnerModel[i].Bound;
//newInnerModel.Draw(CADInterface.bGrp.Graphics);
newInnerModel.ModelId = CADInterface.globalModelID;
CADInterface.globalModelID = CADInterface.globalModelID + 1;
//CADInterface .currentPlates .Add(newInnerModel);
copyPlate.InnerModel.Add(newInnerModel);
}
}
copyPlate.RotateCenter = plate.RotateCenter;
copyPlate.PowCenter = plate.PowCenter;
copyPlate.IsArc = plate.IsArc;
copyPlate.PlateCode = plate.PlateCode;
copyPlate.PlateName = plate.PlateName;
copyPlate.PlateNum = plate.PlateNum;
copyPlate.Area = plate.Area;
copyPlate.Bound = plate.Bound;
copyPlate.Rect = plate.Rect;
copyPlate.GridValue = plate.GridValue == null ? null : plate.GridValue.ToList();
copyPlate.id = plate.id;
copyPlate.GridLen = plate.GridLen;
copyPlate.GridWid = plate.GridWid;
copyPlate.Rect = plate.Rect;
copyPlate.Combine = plate.Combine;
copyPlate.PlateCount = plate.PlateCount;
return(copyPlate);
}
public static bool Update(this IDbConnection connection, BaseModel entity)
{
var query = $"UPDATE [{entity.GetTableName()}] SET {entity.GetUpdateColumnList()} WHERE [{entity.GetIDColumnName()}] = @{entity.GetIDColumnName()}";
return(ExecuteWithEffectedRowsCount(connection, entity, query) > 0);
}
public QuotationTemplateController()
{
_context = new ErpEntities(Constants.ConnectionString);
_quotationTemplate = new BaseModel <iffsQuotationTemplate>(_context);
}
public void ApplyChangesIfModified(BaseModel model)
{
HandleUpdate(model);
}
public BaseModel <object> Items_ListbyType(QueryParams _query)
{
BaseModel <object> _baseModel = new BaseModel <object>();
PageModel _pageModel = new PageModel();
ErrorModel _error = new ErrorModel();
string _keywordSearch = "";
bool _orderBy_ASC = false;
string Token = _account.GetHeader(Request);
try
{
Func <ItemsModel, object> _orderByExpression = x => x.IdItem;
Dictionary <string, Func <ItemsModel, object> > _sortableFields = new Dictionary <string, Func <ItemsModel, object> >
{
{ "IdItem", x => x.IdItem }
};
if (!string.IsNullOrEmpty(_query.sortField) && _sortableFields.ContainsKey(_query.sortField))
{
_orderBy_ASC = ("desc".Equals(_query.sortOrder) ? false : true);
_orderByExpression = _sortableFields[_query.sortField];
}
List <ItemsModel> _data = new List <ItemsModel>();
if (!string.IsNullOrEmpty(_query.filter["type"]))
{
_data = (from item in _context.DBItems
where item.IdType == (_context.DBTypeItems.Where(type =>
type.IdMainMenu == _context.DBMainMenu.Where(menu =>
!menu.IsDisabled &&
menu.Link.Equals(_query.filter["type"]))
.Select(s => s.Id_Main).FirstOrDefault())
.Select(t => t.IdType).FirstOrDefault())
select new ItemsModel
{
IdItem = item.IdItem,
IdType = item.IdType,
Name = item.Name,
Money = item.Money,
Sales = item.Sales,
RateAvg = item.RateAvg,
LinkImage = item.LinkImage
}).ToList();
}
int _countRows = _data.Count();
if (_countRows == 0)
{
_baseModel.status = 0;
_error = new ErrorModel();
_error.message = "Không có dữ liệu hiển thị!";
_error.code = Constant.ERRORCODE_SQL;
_baseModel.error = _error;
return(_baseModel);
}
_pageModel.TotalCount = _countRows;
_pageModel.AllPage = (int)Math.Ceiling(_countRows / (decimal)_query.record);
_pageModel.Size = _query.record;
_pageModel.Page = _query.page;
_pageModel.Page = _query.page;
if (_query.more)
{
_baseModel.status = 1;
_baseModel.error = null;
_baseModel.page = _pageModel;
_baseModel.data = _data.ToList();
return(_baseModel);
}
_baseModel.status = 1;
_baseModel.error = null;
_baseModel.page = _pageModel;
if (_orderBy_ASC)
{
_baseModel.data = _data
.OrderBy(_orderByExpression)
.Skip((_query.page - 1) * _query.record)
.Take(_query.record)
.ToList();
}
else
{
_baseModel.data = _data
.OrderByDescending(_orderByExpression)
.Skip((_query.page - 1) * _query.record)
.Take(_query.record)
.ToList();
}
return(_baseModel);
}
catch (Exception ex)
{
_error = new ErrorModel();
_error.message = "Lỗi dữ liệu hoặc bạn phải truyền Token!";
_error.code = Constant.ERRORCODE;
return(new BaseModel <object>
{
status = 0,
error = _error,
data = null,
page = null
});
}
}
public override IEnumerator ApplyChanges(BaseModel newJson)
{
yield break;
}
void Session_End(object sender, EventArgs e)
{
// perform your logic
BaseModel audit = new BaseModel();
string username = Session["UserName"].ToString();
try
{
if (Application["EditUserSection"] != null)
{
DataTable dt = (DataTable)Application["EditUserSection"];
if (dt.Rows.Count > 0)
{
for (int r = 0; r < dt.Rows.Count; ++r)
{
DataRow dr = dt.Rows[r];
if (dr["UserID"].ToString() == Session["UserID"].ToString())
{
// do your deed
dr.Delete();
}
//...
}
dt.AcceptChanges();
Application["EditUserSection"] = dt;
}
else
{
}
}
using (var httpClient = new HttpClient())
{
var url = ConfigurationManager.AppSettings["WEBAPIURL"];
httpClient.BaseAddress = new Uri(url);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var responseTask = httpClient.PutAsJsonAsync("user/UserLogout?userid=" + Session["UserID"].ToString(), "");
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
using (HttpContent content = result.Content)
{
Task <string> result1 = content.ReadAsStringAsync();
var rs = result1.Result;
dynamic data = JsonConvert.DeserializeObject(rs);
string value = Convert.ToString(data);
}
}
}
}
catch (Exception ex)
{
}
// audit.InsertLogoutAudit("LogOut", "Successfully Logout", "Success", username, Ip);
Session.Abandon();
}
/// <summary>
/// Inherited from <see cref="IValidator"/>
/// <remarks>This implementation returns all results at once. This means that all
/// asyncronous operations complete before a result is returned.</remarks>
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> that will be validated.</param>
/// <param name="callback">An <see cref="AsyncCallback"/> reference that will be called when the operation completes.</param>
/// <param name="state">A user defined object.</param>
/// <returns>An <see cref="IAsyncResult"/> representing the background operation.</returns>
public virtual IAsyncResult BeginValidateModel(BaseModel model, AsyncCallback callback, object state)
{
return new DefaultValidateModelAsyncResult(model, this, callback, state);
}
public async Task <JsonResult> UploadAsync(FullPath path, IEnumerable <IFormFile> files, bool?overwrite, IEnumerable <FullPath> uploadPaths, IEnumerable <string> renames, string suffix)
{
var response = new AddResponseModel();
if (path.RootVolume.MaxUploadSize.HasValue)
{
foreach (var file in files)
{
if (file.Length > path.RootVolume.MaxUploadSize.Value)
{
return(Error.MaxUploadFileSize());
}
}
}
foreach (string rename in renames)
{
var fileInfo = new FileInfo(Path.Combine(path.Directory.FullName, rename));
string destination = Path.Combine(path.Directory.FullName, $"{Path.GetFileNameWithoutExtension(rename)}{suffix}{Path.GetExtension(rename)}");
fileInfo.MoveTo(destination);
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(destination), path.RootVolume));
}
foreach (var uploadPath in uploadPaths)
{
var directory = uploadPath.Directory;
while (directory.FullName != path.RootVolume.RootDirectory)
{
response.Added.Add(await BaseModel.CreateAsync(new FileSystemDirectory(directory.FullName), path.RootVolume));
directory = directory.Parent;
}
}
int i = 0;
foreach (var file in files)
{
string destination = uploadPaths.Count() > i?uploadPaths.ElementAt(i).Directory.FullName : path.Directory.FullName;
var fileInfo = new FileInfo(Path.Combine(destination, Path.GetFileName(file.FileName)));
if (fileInfo.Exists)
{
if (overwrite ?? path.RootVolume.UploadOverwrite)
{
fileInfo.Delete();
using (var fileStream = new FileStream(fileInfo.FullName, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(fileInfo.FullName), path.RootVolume));
}
else
{
string newName = CreateNameForCopy(fileInfo, suffix);
using (var fileStream = new FileStream(Path.Combine(fileInfo.DirectoryName, newName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(newName), path.RootVolume));
}
}
else
{
using (var fileStream = new FileStream(fileInfo.FullName, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(fileInfo.FullName), path.RootVolume));
}
i++;
}
return(await Json(response));
}
public async Task <JsonResult> UploadAsync(FullPath path, IEnumerable <IFormFile> files)
{
int fileCount = files.Count();
var response = new AddResponseModel();
if (path.RootVolume.MaxUploadSize.HasValue)
{
for (int i = 0; i < fileCount; i++)
{
IFormFile file = files.ElementAt(i);
if (file.Length > path.RootVolume.MaxUploadSize.Value)
{
return(Error.MaxUploadFileSize());
}
}
}
foreach (var file in files)
{
var p = new FileInfo(Path.Combine(path.Directory.FullName, Path.GetFileName(file.FileName)));
if (p.Exists)
{
if (path.RootVolume.UploadOverwrite)
{
//if file already exist we rename the current file,
//and if upload is succesfully delete temp file, in otherwise we restore old file
string tmpPath = p.FullName + Guid.NewGuid();
bool uploaded = false;
try
{
using (var fileStream = new FileStream(tmpPath, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
uploaded = true;
}
catch { }
finally
{
if (uploaded)
{
File.Delete(p.FullName);
File.Move(tmpPath, p.FullName);
}
else
{
File.Delete(tmpPath);
}
}
}
else
{
using (var fileStream = new FileStream(Path.Combine(p.DirectoryName, Utils.GetDuplicatedName(p)), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
}
}
else
{
using (var fileStream = new FileStream(p.FullName, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
}
response.Added.Add((FileModel)await BaseModel.Create(this, new FileSystemFile(p.FullName), path.RootVolume));
}
return(await Json(response));
}
public async Task <JsonResult> InitAsync(FullPath path, IEnumerable <string> mimeTypes)
{
if (path == null)
{
var root = Roots.FirstOrDefault(r => r.StartDirectory != null);
if (root == null)
{
root = Roots.First();
}
if (Directory.Exists(root.StartDirectory))
{
path = new FullPath(root, new FileSystemDirectory(root.StartDirectory), null);
}
if (path == null || path.Directory.GetReadFlag(root) == 0)
{
path = new FullPath(root, new FileSystemDirectory(root.RootDirectory), null);
}
}
var response = new InitResponseModel(await BaseModel.CreateAsync(path.Directory, path.RootVolume), new Options(path));
foreach (var item in await path.Directory.GetFilesAsync(mimeTypes))
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
foreach (var item in await path.Directory.GetDirectoriesAsync())
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
foreach (var item in Roots)
{
response.Files.Add(await BaseModel.CreateAsync(new FileSystemDirectory(item.RootDirectory), item));
}
if (path.RootVolume.RootDirectory != path.Directory.FullName)
{
var dirInfo = new DirectoryInfo(path.RootVolume.RootDirectory);
foreach (var item in dirInfo.GetDirectories())
{
var attributes = item.Attributes;
if (!attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(new FileSystemDirectory(item), path.RootVolume));
}
}
}
if (path.RootVolume.MaxUploadSize.HasValue)
{
response.Options.UploadMaxSize = $"{path.RootVolume.MaxUploadSizeInKb.Value}K";
}
return(await Json(response));
}
public async Task <JsonResult> ExtractAsync(FullPath fullPath, bool newFolder)
{
var response = new AddResponseModel();
if (fullPath.IsDirectory || fullPath.File.Extension.ToLower() != ".zip")
{
throw new NotSupportedException("Only .zip files are currently supported.");
}
string rootPath = fullPath.File.Directory.FullName;
if (newFolder)
{
rootPath = Path.Combine(rootPath, Path.GetFileNameWithoutExtension(fullPath.File.Name));
var rootDir = new FileSystemDirectory(rootPath);
if (!await rootDir.ExistsAsync)
{
await rootDir.CreateAsync();
}
response.Added.Add(await BaseModel.CreateAsync(rootDir, fullPath.RootVolume));
}
using (var archive = ZipFile.OpenRead(fullPath.File.FullName))
{
string separator = Path.DirectorySeparatorChar.ToString();
foreach (ZipArchiveEntry entry in archive.Entries)
{
try
{
//Replce zip entry path separator by system path separator
string file = Path.Combine(rootPath, entry.FullName)
.Replace("/", separator).Replace("\\", separator);
if (file.EndsWith(separator)) //directory
{
var dir = new FileSystemDirectory(file);
if (!await dir.ExistsAsync)
{
await dir.CreateAsync();
}
if (!newFolder)
{
response.Added.Add(await BaseModel.CreateAsync(dir, fullPath.RootVolume));
}
}
else
{
entry.ExtractToFile(file, true);
if (!newFolder)
{
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(file), fullPath.RootVolume));
}
}
}
catch //(Exception ex)
{
//throw new Exception(entry.FullName, ex);
}
}
}
return(await Json(response));
}
public async Task <JsonResult> DuplicateAsync(IEnumerable <FullPath> paths)
{
var response = new AddResponseModel();
foreach (var path in paths)
{
if (path.IsDirectory)
{
string parentPath = path.Directory.Parent.FullName;
string name = path.Directory.Name;
string newName = $"{parentPath}{Path.DirectorySeparatorChar}{name} copy";
if (!Directory.Exists(newName))
{
DirectoryCopy(path.Directory.FullName, newName, true);
}
else
{
bool foundNewName = false;
for (int i = 1; i < 100; i++)
{
newName = $"{parentPath}{Path.DirectorySeparatorChar}{name} copy {i}";
if (!Directory.Exists(newName))
{
DirectoryCopy(path.Directory.FullName, newName, true);
foundNewName = true;
break;
}
}
if (!foundNewName)
{
return(Error.NewNameSelectionException($"{name} copy"));
}
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemDirectory(newName), path.RootVolume));
}
else
{
string parentPath = path.File.Directory.FullName;
string name = path.File.Name.Substring(0, path.File.Name.Length - path.File.Extension.Length);
string ext = path.File.Extension;
string newName = $"{parentPath}{Path.DirectorySeparatorChar}{name} copy{ext}";
if (!File.Exists(newName))
{
File.Copy(path.File.FullName, newName);
}
else
{
bool foundNewName = false;
for (int i = 1; i < 100; i++)
{
newName = $"{parentPath}{Path.DirectorySeparatorChar}{name} copy {i}{ext}";
if (!File.Exists(newName))
{
File.Copy(path.File.FullName, newName);
foundNewName = true;
break;
}
}
if (!foundNewName)
{
return(Error.NewNameSelectionException($"{name} copy{ext}"));
}
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(newName), path.RootVolume));
}
}
return(await Json(response));
}
public static List <object> GetParameters <T>(this BaseModel item) where T : BaseModel, new()
=> GetFieldsFromTable(item.GetType()).Select(x => new SqliteParameter($"@{x.Name}", x.GetValue(item)))
.OfType <object>()
.ToList();
public PhraseModel(BaseModel baseModel, List<PhraseEntityModel> phraseEntities)
: base(baseModel)
{
PhraseEntities = phraseEntities;
}
public BaseModel <object> Detail(long id)
{
BaseModel <object> _baseModel = new BaseModel <object>();
PageModel _pageModel = new PageModel();
ErrorModel _error = new ErrorModel();
string Token = _account.GetHeader(Request);
try
{
Func <ItemsModel, object> _orderByExpression = x => x.IdItem;
Dictionary <string, Func <ItemsModel, object> > _sortableFields = new Dictionary <string, Func <ItemsModel, object> >
{
{ "IdItem", x => x.IdItem }
};
ItemsModel _data = (from item in _context.DBItems
where item.IdItem == id
select new ItemsModel
{
IdItem = item.IdItem,
IdType = item.IdType,
Name = item.Name,
Money = item.Money,
Sales = item.Sales,
RateAvg = _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count() <= 0 ? 0 : Decimal.Divide(Decimal.Divide(_context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Select(s => s.Rate).Sum(), _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count()), 5) * 100,
RateNumber = _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count(),
LinkImage = item.LinkImage,
}).ToList().FirstOrDefault();
_data.UserReview = _context.DBReview.Where(x => x.IdItem == id)
.Join(_context.DBAccount,
re => re.IdAccount,
acc => acc.IdAccount,
(re, acc) => new { re = re, acc = acc })
.Join(_context.DBUser,
acc => acc.acc.IdUser,
user => user.IdUser,
(acc, user) => new { acc = acc, user = user })
.Select(s => new UserReview
{
AccountName = s.user.Fullname,
Time = s.acc.re.Time,
Rate = Decimal.Divide(s.acc.re.Rate, 5) * 100,
Text = s.acc.re.Text
}).ToList();
_baseModel.status = 1;
_baseModel.error = null;
_baseModel.data = _data;
_baseModel.page = _pageModel;
return(_baseModel);
}
catch (Exception ex)
{
_error = new ErrorModel();
_error.message = "Lỗi dữ liệu hoặc bạn phải truyền Token!";
_error.code = Constant.ERRORCODE;
return(new BaseModel <object>
{
status = 0,
error = _error,
data = null,
page = null
});
}
}
/// <summary> /// Sets the values of its own variables from the given snapshot /// </summary> /// <param name="snapshot"></param> public abstract void ImportValues(BaseModel snapshot);
public static bool Delete(this IDbConnection connection, BaseModel entity)
{
var affectedrows = connection.Execute($"DELETE FROM [{entity.GetTableName()}] WHERE [{entity.GetIDColumnName()}] = @Id", entity);
return(affectedrows > 0);
}
public int Login(string email, string password, out BaseModel result)
{
return _dao.Login(email, password, out result);
}
public static bool MustVerUp(Context context, BaseModel baseModel)
{
return
(baseModel.Updator.Id != context.UserId ||
baseModel.UpdatedTime.DifferentDate(context: context));
}
public int UpdateSetting(string userID, BaseModel model)
{
return _dao.UpdateSetting(userID, model);
}
/// <summary>Overriding the base implementation, which always returns true. In this case, a views holder is recyclable only if its <see cref="BaseVH.CanPresentModelType(Type)"/> returns true for the model at index <paramref name="indexOfItemThatWillBecomeVisible"/></summary>
/// <seealso cref="OSA{TParams, TItemViewsHolder}.IsRecyclable(TItemViewsHolder, int, double)"/>
protected override bool IsRecyclable(BaseVH potentiallyRecyclable, int indexOfItemThatWillBecomeVisible, double sizeOfItemThatWillBecomeVisible)
{
BaseModel model = Data[indexOfItemThatWillBecomeVisible];
return(potentiallyRecyclable.CanPresentModelType(model.CachedType));
}
public int SelectVocaSetsDataByID(string userID, int vocaSetID, out BaseModel result)
{
return _dao.SelectVocaSetsDataByID(userID, vocaSetID, out result);
}
private static async Task <bool> CreateOrUpdateDocument(BaseModel myObject) // true if success
{
if (NotInit)
{
return(false);
}
string id;
string collectionId;
if (myObject.GetType() == typeof(LiveEventEntry))
{
id = ((LiveEventEntry)myObject).Id;
collectionId = CollectionOutputs;
}
else if (myObject.GetType() == typeof(LiveEventSettingsInfo))
{
id = ((LiveEventSettingsInfo)myObject).Id;
collectionId = CollectionSettings;
}
else if (myObject.GetType() == typeof(StreamingPolicyInfo))
{
id = ((StreamingPolicyInfo)myObject).Id;
collectionId = CollectionStreamingPolicies;
}
else if (myObject.GetType() == typeof(AssetEntry))
{
id = ((AssetEntry)myObject).Id;
collectionId = CollectionVODAssets;
}
else if (myObject.GetType() == typeof(VodResource))
{
id = ((VodResource)myObject).Id;
collectionId = CollectionVODResources;
}
else
{
return(false);
}
try
{
await _client.ReplaceDocumentAsync(
UriFactory.CreateDocumentUri(Database, collectionId, id), myObject);
return(true);
}
catch (DocumentClientException de)
{
if (de.StatusCode != HttpStatusCode.NotFound)
{
throw;
}
}
try // new document
{
await _client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Database, collectionId), myObject);
return(true);
}
catch (DocumentClientException de)
{
if (de.StatusCode != HttpStatusCode.NotFound)
{
throw;
}
}
try // let create the db, collection, and document
{
// we use shared RU for the database (RU are shared among the collections)
await _client.CreateDatabaseIfNotExistsAsync(new Database { Id = Database }, new RequestOptions { OfferThroughput = OfferThroughput });
if (!DoNotUsePartitionMode)
{
await _client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(Database), new DocumentCollection { Id = collectionId, PartitionKey = PartitionKeyDef });
}
else
{
await _client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(Database), new DocumentCollection { Id = collectionId });
}
await _client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Database, collectionId), myObject);
return(true);
}
catch
{
}
return(false);
}
public DomainStatsModel(BaseModel baseModel, List<DomainStatsEntityModel> phraseDomains, PhraseEntityModel phrase)
: base(baseModel)
{
Phrase = phrase;
PhraseDomains = phraseDomains;
}
internal void AddQueue(BaseModel model)
{
dataQueue.Enqueue(model);
}
private static int ExecuteWithEffectedRowsCount(IDbConnection connection, BaseModel entity, string query)
{
return(connection.Execute(query, entity));
}
/// <summary>
/// Inherited from <see cref="IValidator"/>
/// <remarks>This implementation returns all results at once. This means that all
/// asyncronous operations complete before a result is returned.</remarks>
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> that will be validated.</param>
/// <param name="value">The value that needs to be validated.</param>
/// <param name="propertyName">The name of the property who's value has changed and needs to be validated.</param>
/// <param name="callback">An <see cref="AsyncCallback"/> reference that will be called when the operation completes.</param>
/// <param name="state">A user defined object.</param>
/// <returns>An <see cref="IAsyncResult"/> representing the background operation.</returns>
public virtual IAsyncResult BeginValidateProperty(BaseModel model, object value, string propertyName, AsyncCallback callback, object state)
{
return new DefaultValidatePropertyAsyncResult(model, this, value, propertyName, callback, state);
}
public FiringPatternShapeObject(double start, double stop, ref GameContent MainContent, BaseModel fromModel)
{
this.start = start;
this.stop = stop;
this.fromModel = fromModel;
this.MainContent = MainContent;
}
public StatusModel(BaseModel baseModel, ProgressStatusSummary serverProgress)
: base(baseModel)
{
ServerProgress = serverProgress;
}
public FiringPatternTimeObject(ref GameContent MainContent, BaseModel frombModel)
{
this.fromModel = frombModel;
this.MainContent = MainContent;
}
public int UpdateData(BaseModel model)
{
return _dao.InsertData(model);
}
public FiringPatternTimeObject From(BaseModel fromModel)
{
FiringPatternTimeObject fp = new FiringPatternTimeObject(ref MainContent, fromModel);
return(fp);
}
public int UpdateUserState(ref BaseModel result)
{
return _dao.UpdateUserState(ref result);
}
public BaseModelTests()
{
model = Substitute.For <BaseModel>();
}
//public int SelectUserHomePageData(string userID, out BaseModel model)
//{
// return _dao.SelectUserHomePageData(userID, out model);
//}
public int SelectData(BaseModel model, out IEnumerable<BaseModel> results)
{
return _dao.SelectData(model, out results);
}
public ActorRefreshCommand(BaseModel baseModel)
{
BaseModelModel = baseModel;
}
public int SelectDataByID(string id, out BaseModel result)
{
return _dao.SelectDataByID(id, out result);
}
public static List <object> GetIdParameter(this BaseModel model) => new List <object>
{
new SqliteParameter(model.GetType().Name, model.Id)
};
/// <summary>
/// This method will validate a <see cref="BaseModel"/>. Also, if the children of the given
/// model need to be validated at the same time, it can do that as well.
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> to validate.</param>
/// <param name="validateChildren">If the chilren of the given model should be validated as well, supply true.</param>
/// <returns>A boolean value indicating whether the validation was successful or not.</returns>
/// <exception cref="InvalidOperationException">If the engine is not initialized</exception>
public static bool ValidateModel(BaseModel model, bool validateChildren = false)
{
if (!_isInitialized)
throw new InvalidOperationException("You must initialize the engine before it is used.");
IEnumerable<object> validationErrors = CurrentValidator.ValidateModel(model);
ValidationErrorCollection errorCollection = (model as IValidationInteraction).ValidationErrors;
CurrentManager.SetErrors(errorCollection, validationErrors);
//If we're validating the children as well.
if (validateChildren)
{
IEnumerable<PropertyInfo> properties = model.GetType().GetProperties().Where(a => a.CanRead && typeof(BaseModel).IsAssignableFrom(a.PropertyType));
IEnumerable<PropertyInfo> colProperties = model.GetType().GetProperties().Where(a => a.CanRead && typeof(IEnumerable<BaseModel>).IsAssignableFrom(a.PropertyType));
foreach (PropertyInfo pi in properties)
ValidateModel((BaseModel)pi.GetValue(model, null), validateChildren);
foreach (PropertyInfo pi in colProperties)
{
foreach (BaseModel bm in (IEnumerable<BaseModel>)pi.GetValue(model, null))
ValidateModel(bm, validateChildren);
}
}
return validationErrors.Count() == 0;
}
private void OnDestroyEvent(BaseModel destroyedEntity)
{
_entities.Remove((EntityModel)destroyedEntity);
}
public override IEnumerator ApplyChanges(BaseModel newModel)
{
DisablePassport();
var model = (AvatarModel)newModel;
everythingIsLoaded = false;
bool avatarDone = false;
bool avatarFailed = false;
yield return(null); //NOTE(Brian): just in case we have a Object.Destroy waiting to be resolved.
avatarRenderer.ApplyModel(model, () => avatarDone = true, () => avatarFailed = true);
yield return(new WaitUntil(() => avatarDone || avatarFailed));
onPointerDown.Initialize(
new OnPointerDown.Model()
{
type = OnPointerDown.NAME,
button = WebInterface.ACTION_BUTTON.POINTER.ToString(),
hoverText = "view profile"
},
entity
);
CommonScriptableObjects.worldOffset.OnChange -= OnWorldReposition;
CommonScriptableObjects.worldOffset.OnChange += OnWorldReposition;
entity.OnTransformChange -= avatarMovementController.OnTransformChanged;
entity.OnTransformChange += avatarMovementController.OnTransformChanged;
entity.OnTransformChange -= OnEntityTransformChanged;
entity.OnTransformChange += OnEntityTransformChanged;
onPointerDown.OnPointerDownReport -= PlayerClicked;
onPointerDown.OnPointerDownReport += PlayerClicked;
// To deal with the cases in which the entity transform was configured before the AvatarShape
if (!initializedPosition && entity.components.ContainsKey(DCL.Models.CLASS_ID_COMPONENT.TRANSFORM))
{
initializedPosition = true;
avatarMovementController.MoveTo(
entity.gameObject.transform.localPosition - Vector3.up * DCLCharacterController.i.characterController.height / 2,
entity.gameObject.transform.localRotation, true);
}
avatarUserInfo.userId = model.id;
avatarUserInfo.userName = model.name;
avatarUserInfo.worldPosition = lastAvatarPosition != null ? lastAvatarPosition.Value : entity.gameObject.transform.localPosition;
MinimapMetadataController.i?.UpdateMinimapUserInformation(avatarUserInfo);
avatarName.SetName(model.name);
avatarName.SetTalking(model.talking);
avatarCollider.gameObject.SetActive(true);
everythingIsLoaded = true;
OnAvatarShapeUpdated?.Invoke(entity, this);
EnablePassport();
}
public static string ToDeleteQuery(this BaseModel model)
{
return($"DELETE FROM {model.GetType().Name} WHERE Id = @Id");
}
/// <summary>
/// Call this method to clear all validation issues with a given model.
/// </summary>
/// <param name="model">A <see cref="BaseModel"/> to clear validation issues from.</param>
/// <param name="clearChildIssues">A boolean value indicating whether or not to clear child objects issues as well.</param>
public static void ClearValidationIssues(BaseModel model, bool clearChildIssues = false)
{
if (model == null)
return;
(model as IValidationInteraction).ValidationErrors.Clear();
if (clearChildIssues)
{
IEnumerable<PropertyInfo> properties = model.GetType().GetProperties().Where(a => a.CanRead && typeof(BaseModel).IsAssignableFrom(a.PropertyType));
IEnumerable<PropertyInfo> colProperties = model.GetType().GetProperties().Where(a => a.CanRead && typeof(IEnumerable<BaseModel>).IsAssignableFrom(a.PropertyType));
foreach (PropertyInfo pi in properties)
ClearValidationIssues((BaseModel)pi.GetValue(model, null), clearChildIssues);
foreach (PropertyInfo pi in colProperties)
{
foreach (BaseModel bm in (IEnumerable<BaseModel>)pi.GetValue(model, null))
ClearValidationIssues(bm, clearChildIssues);
}
}
}
public async Task <bool> CompleteU2fRegistrationAsync(User user, int id, string name, string deviceResponse)
{
if (string.IsNullOrWhiteSpace(deviceResponse))
{
return(false);
}
var challenges = await _u2fRepository.GetManyByUserIdAsync(user.Id);
if (!challenges?.Any() ?? true)
{
return(false);
}
var registerResponse = BaseModel.FromJson <RegisterResponse>(deviceResponse);
try
{
var challenge = challenges.OrderBy(i => i.Id).Last(i => i.KeyHandle == null);
var startedReg = new StartedRegistration(challenge.Challenge, challenge.AppId);
var reg = U2fLib.FinishRegistration(startedReg, registerResponse);
await _u2fRepository.DeleteManyByUserIdAsync(user.Id);
// Add device
var providers = user.GetTwoFactorProviders();
if (providers == null)
{
providers = new Dictionary <TwoFactorProviderType, TwoFactorProvider>();
}
var provider = user.GetTwoFactorProvider(TwoFactorProviderType.U2f);
if (provider == null)
{
provider = new TwoFactorProvider();
}
if (provider.MetaData == null)
{
provider.MetaData = new Dictionary <string, object>();
}
if (provider.MetaData.Count >= 5)
{
// Can only register up to 5 keys
return(false);
}
var keyId = $"Key{id}";
if (provider.MetaData.ContainsKey(keyId))
{
provider.MetaData.Remove(keyId);
}
provider.Enabled = true;
provider.MetaData.Add(keyId, new TwoFactorProvider.U2fMetaData
{
Name = name,
KeyHandle = reg.KeyHandle == null ? null : Utils.ByteArrayToBase64String(reg.KeyHandle),
PublicKey = reg.PublicKey == null ? null : Utils.ByteArrayToBase64String(reg.PublicKey),
Certificate = reg.AttestationCert == null ? null : Utils.ByteArrayToBase64String(reg.AttestationCert),
Compromised = false,
Counter = reg.Counter
});
if (providers.ContainsKey(TwoFactorProviderType.U2f))
{
providers.Remove(TwoFactorProviderType.U2f);
}
providers.Add(TwoFactorProviderType.U2f, provider);
user.SetTwoFactorProviders(providers);
await UpdateTwoFactorProviderAsync(user, TwoFactorProviderType.U2f);
return(true);
}
catch (U2fException e)
{
Logger.LogError(e, "Complete U2F registration error.");
return(false);
}
}