public async Task <bool> BuildUpdateAsync(UpdateInfoModel updateInfoAll, UpdateInfoModel updateInfo, string outPath, CancellationToken token)
{
return(await Task.Run(() => {
try
{
token.ThrowIfCancellationRequested();
Logger.Instance.Add("Создаем патч лист");
BuildUpdateInfo(updateInfo, outPath);
Logger.Instance.Add("Патч лист создан");
Logger.Instance.Add("Начинаем паковать");
PuckingRecurse(updateInfoAll.Folder, $"{outPath}\\{updateInfoAll.Folder.Name}", token);
Logger.Instance.Add("Все запаковано");
return true;
}
catch (Exception e)
{
Logger.Instance.Add($"Произошла ошибка во время создания апдейта [{e.Message}]");
return false;
}
}));
}
public async Task <ResultModel> UpdatePhoneNumber([FromBody] UpdateInfoModel phoneNumber)
{
var ret = new ResultModel();
if (!_signInManager.IsSignedIn(User))
{
ret.IsSucceeded = false;
ret.ErrorMessage = "未登录";
return(ret);
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
ret.IsSucceeded = false;
ret.ErrorMessage = "找不到当前用户";
return(ret);
}
var result = await _userManager.SetPhoneNumberAsync(user, phoneNumber.Value);
ret.IsSucceeded = result.Succeeded;
if (!ret.IsSucceeded)
{
ret.ErrorMessage = result.Errors.Any() ? result.Errors.Select(i => i.Description).Aggregate((accu, next) => accu + "\n" + next) : "修改失败";
}
return(ret);
}
public bool UpdateUser(UpdateInfoModel updatedInfoModel, WebshopUser userToUpdate, ShippingAddress address)
{
userToUpdate.Email = updatedInfoModel.Email;
userToUpdate.FirstName = updatedInfoModel.FirstName;
userToUpdate.LastName = updatedInfoModel.LastName;
userToUpdate.PhoneNumber = updatedInfoModel.PhoneNumber;
bool addressChanged = updatedInfoModel.PostalCode != address.PostalCode ||
updatedInfoModel.StreetNumber != address.StreetNumber ||
updatedInfoModel.StreetName != address.StreetName ||
updatedInfoModel.CityName != address.CityName;
if (addressChanged)
{
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = updatedInfoModel.PostalCode,
StreetNumber = updatedInfoModel.StreetNumber,
StreetName = updatedInfoModel.StreetName,
CityName = updatedInfoModel.CityName,
Country = updatedInfoModel.Country,
Province = updatedInfoModel.Province,
AssociatedUser = userToUpdate.UserGuid
};
userToUpdate.ShippingAddresses = new List <ShippingAddress>(new ShippingAddress[] { userAddress });
}
context.SaveChanges();
return(addressChanged);
}
public async Task UpdateUserAsync(UpdateInfoModel model, int id)
{
var user = _context.AspNetUser.Where(a => a.AspNetUserId == id).SingleOrDefault();
user.Address = model.Address;
user.FirstName = model.FirstName;
user.MiddleName = model.MiddleName;
user.LastName = model.LastName;
user.BirthDate = model.BirthDate;
user.UserName = model.UserName;
user.Password = model.Password;
user.Gender = model.Gender;
//var appUser = _mapper.Map<ApplicationUser>(user);
//var userResult = await _userManager.CreateAsync(appUser, model.Password);
//var roleResult = await _userManager.AddToRoleAsync(appUser, Role);
//var claimResult = await _userManager.AddClaimAsync(appUser, new Claim(Claim, "True"));
//var my = _mapper.Map<AspNetUser>(model);
_context.Entry(user).State = EntityState.Modified;
_context.SaveChanges();
}
private static void BuildUpdateInfo(UpdateInfoModel updateInfo, string outPath)
{
var serializer = new XmlSerializer(typeof(UpdateInfoModel));
var settings = new XmlWriterSettings {
Indent = true, Encoding = Encoding.UTF8
};
using (var w = XmlWriter.Create($"{outPath}\\UpdateInfo.xml", settings))
serializer.Serialize(w, updateInfo);
}
public async void Update([FromBody] UpdateInfoModel updatedInfoModel, string id)
{
WebshopUser userToUpdate = UserRepository.FindById(id);
if (userToUpdate.Email != updatedInfoModel.Email)
{
string token = await UserManager.GenerateChangeEmailTokenAsync(userToUpdate, updatedInfoModel.Email);
await UserManager.ChangeEmailAsync(userToUpdate, updatedInfoModel.Email, token);
}
ShippingAddress address = AddressRepository
.GetByGuid(userToUpdate.UserGuid);
bool addressChanged = UserRepository.UpdateUser(updatedInfoModel, userToUpdate, address);
if (addressChanged)
{
AddressRepository.DeleteAddress(userToUpdate.UserGuid);
}
}
public async Task <IActionResult> UpdateAccountInformation([FromBody] UpdateInfoModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid)?.Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
ShippingAddress currentAddress = AddressRepository.GetByGuid(user.UserGuid);
if (model.PostalCode != currentAddress.PostalCode)
{
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = model.PostalCode,
StreetNumber = model.StreetNumber,
StreetName = model.StreetName,
CityName = model.CityName,
Country = model.Country,
Province = model.Province,
AssociatedUser = user.UserGuid
};
AddressRepository.DeleteAddress(user.UserGuid);
user.ShippingAddresses = new List <ShippingAddress>(new[] { userAddress });
}
user.PhoneNumber = model.PhoneNumber;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
IdentityResult result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
/// <summary>
/// Valida si hubo cambios en los datos del usuario
/// </summary>
/// <param name="oldUser"></param>
/// <param name="newUser"></param>
/// <returns></returns>
public Boolean HuboCambios(Usuario oldUser, UpdateInfoModel newUser, ref Boolean validaNIT, ref Boolean validaCorreo)
{
Boolean hubo = false;
if (newUser.email != oldUser.correo || newUser.nombre != oldUser.nombre || newUser.apellido != oldUser.apellido ||
newUser.fechaNacimiento != oldUser.fechaNacimiento || newUser.nit != oldUser.nit)
{
hubo = true;
}
if (newUser.nit != oldUser.nit)
{
validaNIT = true;
}
if (newUser.email != oldUser.correo)
{
validaCorreo = true;
}
return(hubo);
}
public IActionResult UpdateUser([FromRoute] int id, [FromBody] UpdateInfoModel model)
{
_user.UpdateUserAsync(model, id);
return(Ok());
}
public JsonResult UpdateInfo(UpdateInfoModel model)
{
int tipo = 0;
string mensaje = "";
string correo = "";
Boolean validaNIT = false;
Boolean guardar = true;
Boolean validaCorreo = false;
try
{
if (!ModelState.IsValid)
{
//Extrae el primer mensaje de error que tenga el modelo
mensaje = ModelState.Values.Select(e => e.Errors).Where(e => e.Count > 0).FirstOrDefault().Select(v => v.ErrorMessage).FirstOrDefault();
}
else
{
var user = (Usuario)Session["usuario"];
if (HuboCambios(user, model, ref validaNIT, ref validaCorreo))
{
using (var db = new VentaArticulosCreditoEntities())
{
if (validaNIT)
{
if (ValidarNIT.ValidaNIT(model.nit))
{
var userNIT = db.Usuario.Where(u => u.nit == model.nit).FirstOrDefault();
if (userNIT == null)
{
user.nit = model.nit;
}
else
{
guardar = false;
mensaje = "Este NIT ya está siendo utilzado";
}
}
else
{
guardar = false;
mensaje = "Ingrese un NIT válido";
}
}
if (validaCorreo)
{
var userMail = db.Usuario.Where(u => u.correo == model.email).FirstOrDefault();
if (userMail != null)
{
guardar = false;
mensaje = "Este correo ya está siendo utilizado";
}
}
if (guardar)
{
user.correo = model.email;
user.nombre = model.nombre;
user.apellido = model.apellido;
user.fechaNacimiento = model.fechaNacimiento;
db.Entry(user).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
tipo = 1;
mensaje = "Información actualizada correctamente";
Session["usuario"] = user;
correo = user.correo;
}
}
}
else
{
mensaje = "Asegurese de modificar al menos un registro";
}
}
}
catch (Exception ex)
{
mensaje = "Error al cambiar contraseña";
}
return(Json(new { tipo = tipo, mensaje = mensaje, correo = correo }, JsonRequestBehavior.AllowGet));
}
public void Build(string oldDirectory, string newDirectory, string patchDirectory, string version)
{
var oldDir = new DirectoryInfo(oldDirectory);
var newDir = new DirectoryInfo(newDirectory);
var patchDir = new DirectoryInfo(Path.Combine(patchDirectory, version));
var oldFiles = oldDir.EnumerateFiles("*", SearchOption.AllDirectories)
.Select(fileInfo => new MyFileInfo(oldDir, fileInfo)).ToList();
var newFiles = newDir.EnumerateFiles("*", SearchOption.AllDirectories)
.Select(fileInfo => new MyFileInfo(newDir, fileInfo)).ToList();
var updatedFiles = newFiles.Join(oldFiles,
nf => nf.RelativePath,
of => of.RelativePath,
(nf, of) => new ChangedFileInfo(of, nf))
.Where(q => !FileUtils.FilesAreEqual(q.OldFile, q.NewFile)).ToList();
var addedFiles = newFiles.Where(q => oldFiles.All(w => w.RelativePath != q.RelativePath)).ToList();
var deletedFiles = oldFiles.Where(q => newFiles.All(w => w.RelativePath != q.RelativePath)).ToList();
if (!patchDir.Exists)
{
patchDir.Create();
}
else
{
patchDir.Delete(true);
patchDir.Refresh();
patchDir.Create();
}
var patchContentDir = patchDir.FullName + @"\Data";
var patchModel = new PatchModel();
patchModel.UpdatedFiles = new List <PatchFileInfo>();
foreach (var fileInfo in updatedFiles)
{
var targetFilePatch = new FileInfo(patchContentDir + fileInfo.RelativePath + ".patch");
if (!targetFilePatch.Directory.Exists)
{
targetFilePatch.Directory.Create();
}
BuildPatchFile(fileInfo.OldFile, fileInfo.NewFile, targetFilePatch.FullName);
targetFilePatch.Refresh();
var fileHash = HashUtility.GetFileHash(fileInfo.NewFile.FullPath);
string patchFilePath;
long fileSize = fileInfo.NewFile.Size;
bool isPatch;
if (targetFilePatch.Length >= fileInfo.NewFile.Size)
{
targetFilePatch.Delete();
File.Copy(fileInfo.NewFile.FullPath, patchContentDir + fileInfo.RelativePath);
patchFilePath = fileInfo.RelativePath;
isPatch = false;
}
else
{
patchFilePath = fileInfo.RelativePath + ".patch";
isPatch = true;
}
patchModel.UpdatedFiles.Add(new PatchFileInfo
{
RelativePath = patchFilePath,
Size = fileSize,
Hash = fileHash,
IsPatch = isPatch
});
}
foreach (var patchFileInfo in addedFiles)
{
var targetFilePatch = new FileInfo(patchContentDir + patchFileInfo.RelativePath);
if (!targetFilePatch.Directory.Exists)
{
targetFilePatch.Directory.Create();
}
File.Copy(patchFileInfo.FullPath, patchContentDir + patchFileInfo.RelativePath);
}
patchModel.Version = version;
patchModel.DeletedFiles = deletedFiles.Select(q => q.RelativePath).ToList();
patchModel.NewFiles = addedFiles.Select(q => new PatchFileInfo
{
RelativePath = q.RelativePath,
Size = q.Size,
Hash = HashUtility.GetFileHash(q.FullPath),
IsPatch = false
}).ToList();
patchModel.ReleaseDateTime = DateTime.UtcNow;
File.WriteAllText(patchDir.FullName + @"\Info.json", JsonConvert.SerializeObject(patchModel, Formatting.Indented));
var zipPath = new FileInfo(Path.Combine(patchDirectory, version + ".zip"));
if (zipPath.Exists)
{
zipPath.Delete();
}
ZipFile.CreateFromDirectory(patchDir.FullName, zipPath.FullName, CompressionLevel.Optimal, false, Encoding.UTF8);
zipPath.Refresh();
patchDir.Delete(true);
var patchesInfoFile = new FileInfo(Path.Combine(patchDirectory, "Info.json"));
UpdateInfoModel updateModel;
if (patchesInfoFile.Exists)
{
updateModel = JsonConvert.DeserializeObject <UpdateInfoModel>(File.ReadAllText(patchesInfoFile.FullName));
}
else
{
updateModel = new UpdateInfoModel()
{
Patches = new List <VersionModel>()
};
}
if (updateModel.Patches.All(q => q.Version != version))
{
updateModel.Patches.Add(new VersionModel()
{
Version = version,
ReleaseDateTime = DateTime.UtcNow,
Size = zipPath.Length
});
File.WriteAllText(patchesInfoFile.FullName, JsonConvert.SerializeObject(updateModel, Formatting.Indented));
}
MessageBox.Show("Patch created!");
}
private static async Task CheckUpdateAsync()
{
string xml = await _webClient.DownloadStringTaskAsync(UpdateUrl);
var stringReader = new StringReader(xml);
var xmlSerializer = new XmlSerializer(typeof(UpdateInfoModel));
UpdateInfoModel updateInfo = (UpdateInfoModel)xmlSerializer.Deserialize(stringReader);
_changelog = await _webClient.DownloadStringTaskAsync(updateInfo.ChangelogUrl);
_extraLink = updateInfo.ExtraLink;
string[] fields =
{
updateInfo.LauncherInfo.Version,
updateInfo.ScriptInfo.FileHash.Value,
updateInfo.ResourceInfo.Version,
updateInfo.LauncherInfo.DownloadUrl,
updateInfo.ScriptInfo.DownloadUrl,
updateInfo.ResourceInfo.DownloadUrl
};
foreach (var field in fields)
{
if (string.IsNullOrEmpty(field))
{
throw new MissingFieldException("缺失必要的更新字段。");
}
}
Version localLauncherVersion = Application.ResourceAssembly.GetName().Version;
Checksum localScriptHash = Misc.GetHash("cn.file", updateInfo.ScriptInfo.FileHash.HashAlgorithm);
Version localResourceVersion = Misc.GetResourceVersion();
Version remoteResourceVersion = new Version(updateInfo.ResourceInfo.Version);
void EnqueueUpdate(UpdateInfoModel.Item info, bool isRestartNeeded = false)
{
_updateItems.Enqueue(new UpdateItem()
{
IsRestartNeeded = isRestartNeeded,
DownloadUri = new Uri(info.DownloadUrl),
PackageHash = info.PackageHash
});
}
if (localScriptHash != updateInfo.ScriptInfo.FileHash)
{
EnqueueUpdate(updateInfo.ScriptInfo);
}
if (localResourceVersion < remoteResourceVersion)
{
if (localResourceVersion.Major == remoteResourceVersion.Major)
{
EnqueueUpdate(updateInfo.ResourceInfo);
}
else
{
_needManualUpdate = true;
}
}
if (localLauncherVersion < new Version(updateInfo.LauncherInfo.Version))
{
EnqueueUpdate(updateInfo.LauncherInfo, true);
}
}
