public bool RegistraNovaApostila(int idMaterial, int matricula)
        {
            using (var ctx = new DesenvContext())
            {
                var original = (from o in ctx.tblMaterialApostila
                                where o.intProductId == idMaterial
                                select new MaterialApostila()
                {
                    Id = o.intID,
                    PdfId = (int)o.intProductId,
                    Conteudo = o.txtConteudo,
                    DataAtualizacao = o.dteDataCriacao
                }).FirstOrDefault();


                //criar chave do arquivo que vai ser salvo no S3
                var chaveArquivo = Utilidades.CriarNomeApostila(matricula, original.Id, 1);

                ctx.tblMaterialApostilaAluno.Add(new tblMaterialApostilaAluno()
                {
                    intClientID           = matricula,
                    bitAtiva              = 1,
                    dteDataCriacao        = DateTime.Now,
                    intMaterialApostilaID = original.Id,
                    txtApostilaNameId     = chaveArquivo,
                    txtConteudo           = ""
                });

                var materialApostilaAlunoManager = new MaterialApostilaAlunoManager();
                using (MiniProfiler.Current.Step("Salvando nova apostila"))
                {
                    if (materialApostilaAlunoManager.SalvarArquivo(chaveArquivo, original.Conteudo))
                    {
                        return(ctx.SaveChanges() == 1);
                    }
                }

                return(false);
            }
        }
        private int InsereNovaVersao(int matricula, int idApostila, string conteudo)
        {
            using (var ctx = new DesenvContext())
            {
                var ultimaAtiva = ctx.tblMaterialApostilaAluno
                                  .Where(x => x.bitAtiva == 1 &&
                                         x.intClientID == matricula &&
                                         x.intMaterialApostilaID == idApostila)
                                  .OrderBy(y => y.dteDataCriacao)
                                  .FirstOrDefault();


                if (ultimaAtiva != null)
                {
                    long versao = 1;

                    if (ultimaAtiva.txtApostilaNameId != "")
                    {
                        var ultimaVersao = Utilidades.GetDetalhesApostila(ultimaAtiva);
                        versao = ultimaVersao.Versao + 1;
                    }

                    //chave do arquivo que vai ser salvo no S3
                    var chaveArquivo = Utilidades.CriarNomeApostila(matricula, idApostila, versao);

                    //atualiza a chave para a nova versao
                    ultimaAtiva.txtApostilaNameId = chaveArquivo;

                    //após salvar o na tabela MaterialApostilaAluno, salvar o arquivo no bucket com o nome que foi criado
                    var materialApostilaAlunoManager = new MaterialApostilaAlunoManager();
                    using (MiniProfiler.Current.Step("Salvando nova versão de apostila no S3"))
                    {
                        if (materialApostilaAlunoManager.SalvarArquivo(chaveArquivo, conteudo))
                        {
                            ctx.SaveChanges();
                        }
                        else
                        {
                            return(0);
                        }
                    }
                }
                else
                {
                    var apostila = ctx.tblMaterialApostila.
                                   Where(x => x.intID == idApostila).
                                   FirstOrDefault();

                    if (!RegistraNovaApostila(apostila.intProductId.Value, matricula))
                    {
                        return(0);
                    }
                }


                int count = ctx.tblMaterialApostilaAluno
                            .Count(x => x.intClientID == matricula &&
                                   x.intMaterialApostilaID == idApostila &&
                                   x.bitAtiva == 1);
                if (count > 10)
                {
                    DeletaUltimaVersao(matricula, idApostila);
                }

                return(1);
            }
        }
        public MaterialApostilaAluno GetUltimaApostila(int MaterialId, int matricula, int IdVersao)
        {
            var apostilaAluno = new MaterialApostilaAluno();

            var materialApostilaAlunoManager = new MaterialApostilaAlunoManager();

            using (var ctx = new DesenvContext())
            {
                var query = (from a in ctx.tblMaterialApostilaAluno
                             join b in ctx.tblMaterialApostila on a.intMaterialApostilaID equals b.intID
                             where a.bitAtiva == 1 && a.intClientID == matricula && b.intProductId == MaterialId
                             select new MaterialApostilaAluno()
                {
                    DataAtualizacao = a.dteDataCriacao,
                    Id = a.intID,
                    PdfId = b.intProductId.Value,
                    ClientId = a.intClientID.Value,
                    ApostilaId = a.intMaterialApostilaID.Value,
                    Ativa = a.bitAtiva == 1,
                    EntidadeId = b.intProductId.Value
                });


                apostilaAluno = query.OrderByDescending(x => x.Id).FirstOrDefault();



                if (apostilaAluno != null)
                {
                    apostilaAluno.DataRelease = GetDataReleaseApostila(MaterialId, matricula);

                    var anoRelease = GetAnoReleaseApostila(MaterialId);

                    apostilaAluno.Configs = ctx.tblMaterialApostilaConfig
                                            .Select(x => new MaterialApostilaConfig()
                    {
                        Descricao = x.txtDescricao,
                        Ativa     = x.bitAtiva
                    })
                                            .ToList();

                    //carrega o link do css da apostila
                    var cssName = GetNameCss(MaterialId, anoRelease);
                    apostilaAluno.LinkCss = GetApostilaCss(anoRelease, cssName);

                    //carregar o material do aluno para obter o nome da apostila que está no S3
                    var materialApostilaAluno = ctx.tblMaterialApostilaAluno
                                                .Where(x => x.intClientID == matricula && x.intMaterialApostilaID == apostilaAluno.ApostilaId && x.bitAtiva == 1)
                                                .FirstOrDefault();

                    var apostilaVersao = Utilidades.GetDetalhesApostila(materialApostilaAluno);

                    //carregar o conteudo da apostila do aluno
                    string chave = Utilidades.CriarNomeApostila(matricula, apostilaAluno.ApostilaId, apostilaVersao.Versao);
                    apostilaAluno.Conteudo = materialApostilaAlunoManager.ObterArquivo(chave);

                    //retorna se o aluno tem permissão de edição do material
                    var alunoEntity = new AlunoEntity();
                    if (alunoEntity.IsAlunoPendentePagamento(matricula))
                    {
                        apostilaAluno.Bloqueado = false;
                    }
                    else
                    {
                        apostilaAluno.Bloqueado = alunoEntity.IsExAlunoTodosProdutos(matricula);
                    }

                    var anoAtual    = Utilidades.GetYear();
                    var anoApostila = Utilidades.UnixTimeStampToDateTime(apostilaAluno.DataRelease).Year;
                    apostilaAluno.NaoInterageDuvidas = apostilaAluno.Bloqueado ? apostilaAluno.Bloqueado : anoApostila < anoAtual;
                }
            }

            return(apostilaAluno);
        }